From 45f86ecc63e0a55db473d19df199f400b8c25f54 Mon Sep 17 00:00:00 2001 From: Jeddunk Date: Wed, 23 Dec 2020 12:34:31 +0100 Subject: [PATCH] Added link to forum search Added status bar List of DLC is now monospaced Fixed weird crash with search result window --- Annotations/Annotations.cs | 1236 ++++++++++++++++++++++++++++++++++++ CourierPrime-Regular.ttf | Bin 0 -> 68128 bytes MainWindow.xaml | 48 +- MainWindow.xaml.cs | 80 ++- Model/CacheModel.cs | 30 +- Model/CreamConfigModel.cs | 107 ++-- Model/CreamDllModel.cs | 26 +- POCOs/SteamAppPOCOs.cs | 12 +- SearchResultWindow.xaml | 2 +- SearchResultWindow.xaml.cs | 14 +- auto-creamapi.csproj | 21 +- 11 files changed, 1447 insertions(+), 129 deletions(-) create mode 100644 Annotations/Annotations.cs create mode 100644 CourierPrime-Regular.ttf diff --git a/Annotations/Annotations.cs b/Annotations/Annotations.cs new file mode 100644 index 0000000..7360e10 --- /dev/null +++ b/Annotations/Annotations.cs @@ -0,0 +1,1236 @@ +/* MIT License + +Copyright (c) 2016 JetBrains http://www.jetbrains.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; +// ReSharper disable InheritdocConsiderUsage + +#pragma warning disable 1591 +// ReSharper disable UnusedMember.Global +// ReSharper disable MemberCanBePrivate.Global +// ReSharper disable UnusedAutoPropertyAccessor.Global +// ReSharper disable IntroduceOptionalParameters.Global +// ReSharper disable MemberCanBeProtected.Global +// ReSharper disable InconsistentNaming + +namespace auto_creamapi.Annotations +{ + /// + /// Indicates that the value of the marked element could be null sometimes, + /// so checking for null is required before its usage. + /// + /// + /// [CanBeNull] object Test() => null; + /// + /// void UseTest() { + /// var p = Test(); + /// var s = p.ToString(); // Warning: Possible 'System.NullReferenceException' + /// } + /// + [AttributeUsage( + AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property | + AttributeTargets.Delegate | AttributeTargets.Field | AttributeTargets.Event | + AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.GenericParameter)] + public sealed class CanBeNullAttribute : Attribute { } + + /// + /// Indicates that the value of the marked element can never be null. + /// + /// + /// [NotNull] object Foo() { + /// return null; // Warning: Possible 'null' assignment + /// } + /// + [AttributeUsage( + AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property | + AttributeTargets.Delegate | AttributeTargets.Field | AttributeTargets.Event | + AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.GenericParameter)] + public sealed class NotNullAttribute : Attribute { } + + /// + /// Can be applied to symbols of types derived from IEnumerable as well as to symbols of Task + /// and Lazy classes to indicate that the value of a collection item, of the Task.Result property + /// or of the Lazy.Value property can never be null. + /// + /// + /// public void Foo([ItemNotNull]List<string> books) + /// { + /// foreach (var book in books) { + /// if (book != null) // Warning: Expression is always true + /// Console.WriteLine(book.ToUpper()); + /// } + /// } + /// + [AttributeUsage( + AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property | + AttributeTargets.Delegate | AttributeTargets.Field)] + public sealed class ItemNotNullAttribute : Attribute { } + + /// + /// Can be applied to symbols of types derived from IEnumerable as well as to symbols of Task + /// and Lazy classes to indicate that the value of a collection item, of the Task.Result property + /// or of the Lazy.Value property can be null. + /// + /// + /// public void Foo([ItemCanBeNull]List<string> books) + /// { + /// foreach (var book in books) + /// { + /// // Warning: Possible 'System.NullReferenceException' + /// Console.WriteLine(book.ToUpper()); + /// } + /// } + /// + [AttributeUsage( + AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property | + AttributeTargets.Delegate | AttributeTargets.Field)] + public sealed class ItemCanBeNullAttribute : Attribute { } + + /// + /// Indicates that the marked method builds string by the format pattern and (optional) arguments. + /// The parameter, which contains the format string, should be given in constructor. The format string + /// should be in -like form. + /// + /// + /// [StringFormatMethod("message")] + /// void ShowError(string message, params object[] args) { /* do something */ } + /// + /// void Foo() { + /// ShowError("Failed: {0}"); // Warning: Non-existing argument in format string + /// } + /// + [AttributeUsage( + AttributeTargets.Constructor | AttributeTargets.Method | + AttributeTargets.Property | AttributeTargets.Delegate)] + public sealed class StringFormatMethodAttribute : Attribute + { + /// + /// Specifies which parameter of an annotated method should be treated as the format string + /// + public StringFormatMethodAttribute([NotNull] string formatParameterName) + { + FormatParameterName = formatParameterName; + } + + [NotNull] public string FormatParameterName { get; } + } + + /// + /// Use this annotation to specify a type that contains static or const fields + /// with values for the annotated property/field/parameter. + /// The specified type will be used to improve completion suggestions. + /// + /// + /// namespace TestNamespace + /// { + /// public class Constants + /// { + /// public static int INT_CONST = 1; + /// public const string STRING_CONST = "1"; + /// } + /// + /// public class Class1 + /// { + /// [ValueProvider("TestNamespace.Constants")] public int myField; + /// public void Foo([ValueProvider("TestNamespace.Constants")] string str) { } + /// + /// public void Test() + /// { + /// Foo(/*try completion here*/);// + /// myField = /*try completion here*/ + /// } + /// } + /// } + /// + [AttributeUsage( + AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.Field, + AllowMultiple = true)] + public sealed class ValueProviderAttribute : Attribute + { + public ValueProviderAttribute([NotNull] string name) + { + Name = name; + } + + [NotNull] public string Name { get; } + } + + /// + /// Indicates that the integral value falls into the specified interval. + /// It's allowed to specify multiple non-intersecting intervals. + /// Values of interval boundaries are inclusive. + /// + /// + /// void Foo([ValueRange(0, 100)] int value) { + /// if (value == -1) { // Warning: Expression is always 'false' + /// ... + /// } + /// } + /// + [AttributeUsage( + AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property | + AttributeTargets.Method | AttributeTargets.Delegate, + AllowMultiple = true)] + public sealed class ValueRangeAttribute : Attribute + { + public object From { get; } + public object To { get; } + + public ValueRangeAttribute(long from, long to) + { + From = from; + To = to; + } + + public ValueRangeAttribute(ulong from, ulong to) + { + From = from; + To = to; + } + + public ValueRangeAttribute(long value) + { + From = To = value; + } + + public ValueRangeAttribute(ulong value) + { + From = To = value; + } + } + + /// + /// Indicates that the integral value never falls below zero. + /// + /// + /// void Foo([NonNegativeValue] int value) { + /// if (value == -1) { // Warning: Expression is always 'false' + /// ... + /// } + /// } + /// + [AttributeUsage( + AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property | + AttributeTargets.Method | AttributeTargets.Delegate)] + public sealed class NonNegativeValueAttribute : Attribute { } + + /// + /// Indicates that the function argument should be a string literal and match one + /// of the parameters of the caller function. For example, ReSharper annotates + /// the parameter of . + /// + /// + /// void Foo(string param) { + /// if (param == null) + /// throw new ArgumentNullException("par"); // Warning: Cannot resolve symbol + /// } + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class InvokerParameterNameAttribute : Attribute { } + + /// + /// Indicates that the method is contained in a type that implements + /// System.ComponentModel.INotifyPropertyChanged interface and this method + /// is used to notify that some property value changed. + /// + /// + /// The method should be non-static and conform to one of the supported signatures: + /// + /// NotifyChanged(string) + /// NotifyChanged(params string[]) + /// NotifyChanged{T}(Expression{Func{T}}) + /// NotifyChanged{T,U}(Expression{Func{T,U}}) + /// SetProperty{T}(ref T, T, string) + /// + /// + /// + /// public class Foo : INotifyPropertyChanged { + /// public event PropertyChangedEventHandler PropertyChanged; + /// + /// [NotifyPropertyChangedInvocator] + /// protected virtual void NotifyChanged(string propertyName) { ... } + /// + /// string _name; + /// + /// public string Name { + /// get { return _name; } + /// set { _name = value; NotifyChanged("LastName"); /* Warning */ } + /// } + /// } + /// + /// Examples of generated notifications: + /// + /// NotifyChanged("Property") + /// NotifyChanged(() => Property) + /// NotifyChanged((VM x) => x.Property) + /// SetProperty(ref myField, value, "Property") + /// + /// + [AttributeUsage(AttributeTargets.Method)] + public sealed class NotifyPropertyChangedInvocatorAttribute : Attribute + { + public NotifyPropertyChangedInvocatorAttribute() { } + public NotifyPropertyChangedInvocatorAttribute([NotNull] string parameterName) + { + ParameterName = parameterName; + } + + [CanBeNull] public string ParameterName { get; } + } + + /// + /// Describes dependency between method input and output. + /// + /// + ///

Function Definition Table syntax:

+ /// + /// FDT ::= FDTRow [;FDTRow]* + /// FDTRow ::= Input => Output | Output <= Input + /// Input ::= ParameterName: Value [, Input]* + /// Output ::= [ParameterName: Value]* {halt|stop|void|nothing|Value} + /// Value ::= true | false | null | notnull | canbenull + /// + /// If the method has a single input parameter, its name could be omitted.
+ /// Using halt (or void/nothing, which is the same) for the method output + /// means that the method doesn't return normally (throws or terminates the process).
+ /// Value canbenull is only applicable for output parameters.
+ /// You can use multiple [ContractAnnotation] for each FDT row, or use single attribute + /// with rows separated by semicolon. There is no notion of order rows, all rows are checked + /// for applicability and applied per each program state tracked by the analysis engine.
+ /// + /// + /// + /// [ContractAnnotation("=> halt")] + /// public void TerminationMethod() + /// + /// + /// [ContractAnnotation("null <= param:null")] // reverse condition syntax + /// public string GetName(string surname) + /// + /// + /// [ContractAnnotation("s:null => true")] + /// public bool IsNullOrEmpty(string s) // string.IsNullOrEmpty() + /// + /// + /// // A method that returns null if the parameter is null, + /// // and not null if the parameter is not null + /// [ContractAnnotation("null => null; notnull => notnull")] + /// public object Transform(object data) + /// + /// + /// [ContractAnnotation("=> true, result: notnull; => false, result: null")] + /// public bool TryParse(string s, out Person result) + /// + /// + [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)] + public sealed class ContractAnnotationAttribute : Attribute + { + public ContractAnnotationAttribute([NotNull] string contract) + : this(contract, false) { } + + public ContractAnnotationAttribute([NotNull] string contract, bool forceFullStates) + { + Contract = contract; + ForceFullStates = forceFullStates; + } + + [NotNull] public string Contract { get; } + + public bool ForceFullStates { get; } + } + + /// + /// Indicates whether the marked element should be localized. + /// + /// + /// [LocalizationRequiredAttribute(true)] + /// class Foo { + /// string str = "my string"; // Warning: Localizable string + /// } + /// + [AttributeUsage(AttributeTargets.All)] + public sealed class LocalizationRequiredAttribute : Attribute + { + public LocalizationRequiredAttribute() : this(true) { } + + public LocalizationRequiredAttribute(bool required) + { + Required = required; + } + + public bool Required { get; } + } + + /// + /// Indicates that the value of the marked type (or its derivatives) + /// cannot be compared using '==' or '!=' operators and Equals() + /// should be used instead. However, using '==' or '!=' for comparison + /// with null is always permitted. + /// + /// + /// [CannotApplyEqualityOperator] + /// class NoEquality { } + /// + /// class UsesNoEquality { + /// void Test() { + /// var ca1 = new NoEquality(); + /// var ca2 = new NoEquality(); + /// if (ca1 != null) { // OK + /// bool condition = ca1 == ca2; // Warning + /// } + /// } + /// } + /// + [AttributeUsage(AttributeTargets.Interface | AttributeTargets.Class | AttributeTargets.Struct)] + public sealed class CannotApplyEqualityOperatorAttribute : Attribute { } + + /// + /// When applied to a target attribute, specifies a requirement for any type marked + /// with the target attribute to implement or inherit specific type or types. + /// + /// + /// [BaseTypeRequired(typeof(IComponent)] // Specify requirement + /// class ComponentAttribute : Attribute { } + /// + /// [Component] // ComponentAttribute requires implementing IComponent interface + /// class MyComponent : IComponent { } + /// + [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)] + [BaseTypeRequired(typeof(Attribute))] + public sealed class BaseTypeRequiredAttribute : Attribute + { + public BaseTypeRequiredAttribute([NotNull] Type baseType) + { + BaseType = baseType; + } + + [NotNull] public Type BaseType { get; } + } + + /// + /// Indicates that the marked symbol is used implicitly (e.g. via reflection, in external library), + /// so this symbol will not be reported as unused (as well as by other usage inspections). + /// + [AttributeUsage(AttributeTargets.All)] + public sealed class UsedImplicitlyAttribute : Attribute + { + public UsedImplicitlyAttribute() + : this(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Default) { } + + public UsedImplicitlyAttribute(ImplicitUseKindFlags useKindFlags) + : this(useKindFlags, ImplicitUseTargetFlags.Default) { } + + public UsedImplicitlyAttribute(ImplicitUseTargetFlags targetFlags) + : this(ImplicitUseKindFlags.Default, targetFlags) { } + + public UsedImplicitlyAttribute(ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags) + { + UseKindFlags = useKindFlags; + TargetFlags = targetFlags; + } + + public ImplicitUseKindFlags UseKindFlags { get; } + + public ImplicitUseTargetFlags TargetFlags { get; } + } + + /// + /// Can be applied to attributes, type parameters, and parameters of a type assignable from . + /// When applied to an attribute, the decorated attribute behaves the same as . + /// When applied to a type parameter or to a parameter of type , indicates that the corresponding type + /// is used implicitly. + /// + [AttributeUsage(AttributeTargets.Class | AttributeTargets.GenericParameter | AttributeTargets.Parameter)] + public sealed class MeansImplicitUseAttribute : Attribute + { + public MeansImplicitUseAttribute() + : this(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Default) { } + + public MeansImplicitUseAttribute(ImplicitUseKindFlags useKindFlags) + : this(useKindFlags, ImplicitUseTargetFlags.Default) { } + + public MeansImplicitUseAttribute(ImplicitUseTargetFlags targetFlags) + : this(ImplicitUseKindFlags.Default, targetFlags) { } + + public MeansImplicitUseAttribute(ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags) + { + UseKindFlags = useKindFlags; + TargetFlags = targetFlags; + } + + [UsedImplicitly] public ImplicitUseKindFlags UseKindFlags { get; } + + [UsedImplicitly] public ImplicitUseTargetFlags TargetFlags { get; } + } + + /// + /// Specify the details of implicitly used symbol when it is marked + /// with or . + /// + [Flags] + public enum ImplicitUseKindFlags + { + Default = Access | Assign | InstantiatedWithFixedConstructorSignature, + /// Only entity marked with attribute considered used. + Access = 1, + /// Indicates implicit assignment to a member. + Assign = 2, + /// + /// Indicates implicit instantiation of a type with fixed constructor signature. + /// That means any unused constructor parameters won't be reported as such. + /// + InstantiatedWithFixedConstructorSignature = 4, + /// Indicates implicit instantiation of a type. + InstantiatedNoFixedConstructorSignature = 8, + } + + /// + /// Specify what is considered to be used implicitly when marked + /// with or . + /// + [Flags] + public enum ImplicitUseTargetFlags + { + Default = Itself, + Itself = 1, + /// Members of entity marked with attribute are considered used. + Members = 2, + /// Inherited entities are considered used. + WithInheritors = 4, + /// Entity marked with attribute and all its members considered used. + WithMembers = Itself | Members + } + + /// + /// This attribute is intended to mark publicly available API + /// which should not be removed and so is treated as used. + /// + [MeansImplicitUse(ImplicitUseTargetFlags.WithMembers)] + [AttributeUsage(AttributeTargets.All, Inherited = false)] + public sealed class PublicAPIAttribute : Attribute + { + public PublicAPIAttribute() { } + + public PublicAPIAttribute([NotNull] string comment) + { + Comment = comment; + } + + [CanBeNull] public string Comment { get; } + } + + /// + /// Tells code analysis engine if the parameter is completely handled when the invoked method is on stack. + /// If the parameter is a delegate, indicates that delegate is executed while the method is executed. + /// If the parameter is an enumerable, indicates that it is enumerated while the method is executed. + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class InstantHandleAttribute : Attribute { } + + /// + /// Indicates that a method does not make any observable state changes. + /// The same as System.Diagnostics.Contracts.PureAttribute. + /// + /// + /// [Pure] int Multiply(int x, int y) => x * y; + /// + /// void M() { + /// Multiply(123, 42); // Warning: Return value of pure method is not used + /// } + /// + [AttributeUsage(AttributeTargets.Method)] + public sealed class PureAttribute : Attribute { } + + /// + /// Indicates that the return value of the method invocation must be used. + /// + /// + /// Methods decorated with this attribute (in contrast to pure methods) might change state, + /// but make no sense without using their return value.
+ /// Similarly to , this attribute + /// will help detecting usages of the method when the return value in not used. + /// Additionally, you can optionally specify a custom message, which will be used when showing warnings, e.g. + /// [MustUseReturnValue("Use the return value to...")]. + /// + [AttributeUsage(AttributeTargets.Method)] + public sealed class MustUseReturnValueAttribute : Attribute + { + public MustUseReturnValueAttribute() { } + + public MustUseReturnValueAttribute([NotNull] string justification) + { + Justification = justification; + } + + [CanBeNull] public string Justification { get; } + } + + /// + /// Indicates the type member or parameter of some type, that should be used instead of all other ways + /// to get the value of that type. This annotation is useful when you have some "context" value evaluated + /// and stored somewhere, meaning that all other ways to get this value must be consolidated with existing one. + /// + /// + /// class Foo { + /// [ProvidesContext] IBarService _barService = ...; + /// + /// void ProcessNode(INode node) { + /// DoSomething(node, node.GetGlobalServices().Bar); + /// // ^ Warning: use value of '_barService' field + /// } + /// } + /// + [AttributeUsage( + AttributeTargets.Field | AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.Method | + AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.Struct | AttributeTargets.GenericParameter)] + public sealed class ProvidesContextAttribute : Attribute { } + + /// + /// Indicates that a parameter is a path to a file or a folder within a web project. + /// Path can be relative or absolute, starting from web root (~). + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class PathReferenceAttribute : Attribute + { + public PathReferenceAttribute() { } + + public PathReferenceAttribute([NotNull, PathReference] string basePath) + { + BasePath = basePath; + } + + [CanBeNull] public string BasePath { get; } + } + + /// + /// An extension method marked with this attribute is processed by code completion + /// as a 'Source Template'. When the extension method is completed over some expression, its source code + /// is automatically expanded like a template at call site. + /// + /// + /// Template method body can contain valid source code and/or special comments starting with '$'. + /// Text inside these comments is added as source code when the template is applied. Template parameters + /// can be used either as additional method parameters or as identifiers wrapped in two '$' signs. + /// Use the attribute to specify macros for parameters. + /// + /// + /// In this example, the 'forEach' method is a source template available over all values + /// of enumerable types, producing ordinary C# 'foreach' statement and placing caret inside block: + /// + /// [SourceTemplate] + /// public static void forEach<T>(this IEnumerable<T> xs) { + /// foreach (var x in xs) { + /// //$ $END$ + /// } + /// } + /// + /// + [AttributeUsage(AttributeTargets.Method)] + public sealed class SourceTemplateAttribute : Attribute { } + + /// + /// Allows specifying a macro for a parameter of a source template. + /// + /// + /// You can apply the attribute on the whole method or on any of its additional parameters. The macro expression + /// is defined in the property. When applied on a method, the target + /// template parameter is defined in the property. To apply the macro silently + /// for the parameter, set the property value = -1. + /// + /// + /// Applying the attribute on a source template method: + /// + /// [SourceTemplate, Macro(Target = "item", Expression = "suggestVariableName()")] + /// public static void forEach<T>(this IEnumerable<T> collection) { + /// foreach (var item in collection) { + /// //$ $END$ + /// } + /// } + /// + /// Applying the attribute on a template method parameter: + /// + /// [SourceTemplate] + /// public static void something(this Entity x, [Macro(Expression = "guid()", Editable = -1)] string newguid) { + /// /*$ var $x$Id = "$newguid$" + x.ToString(); + /// x.DoSomething($x$Id); */ + /// } + /// + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method, AllowMultiple = true)] + public sealed class MacroAttribute : Attribute + { + /// + /// Allows specifying a macro that will be executed for a source template + /// parameter when the template is expanded. + /// + [CanBeNull] public string Expression { get; set; } + + /// + /// Allows specifying which occurrence of the target parameter becomes editable when the template is deployed. + /// + /// + /// If the target parameter is used several times in the template, only one occurrence becomes editable; + /// other occurrences are changed synchronously. To specify the zero-based index of the editable occurrence, + /// use values >= 0. To make the parameter non-editable when the template is expanded, use -1. + /// + public int Editable { get; set; } + + /// + /// Identifies the target parameter of a source template if the + /// is applied on a template method. + /// + [CanBeNull] public string Target { get; set; } + } + + [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = true)] + public sealed class AspMvcAreaMasterLocationFormatAttribute : Attribute + { + public AspMvcAreaMasterLocationFormatAttribute([NotNull] string format) + { + Format = format; + } + + [NotNull] public string Format { get; } + } + + [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = true)] + public sealed class AspMvcAreaPartialViewLocationFormatAttribute : Attribute + { + public AspMvcAreaPartialViewLocationFormatAttribute([NotNull] string format) + { + Format = format; + } + + [NotNull] public string Format { get; } + } + + [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = true)] + public sealed class AspMvcAreaViewLocationFormatAttribute : Attribute + { + public AspMvcAreaViewLocationFormatAttribute([NotNull] string format) + { + Format = format; + } + + [NotNull] public string Format { get; } + } + + [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = true)] + public sealed class AspMvcMasterLocationFormatAttribute : Attribute + { + public AspMvcMasterLocationFormatAttribute([NotNull] string format) + { + Format = format; + } + + [NotNull] public string Format { get; } + } + + [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = true)] + public sealed class AspMvcPartialViewLocationFormatAttribute : Attribute + { + public AspMvcPartialViewLocationFormatAttribute([NotNull] string format) + { + Format = format; + } + + [NotNull] public string Format { get; } + } + + [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = true)] + public sealed class AspMvcViewLocationFormatAttribute : Attribute + { + public AspMvcViewLocationFormatAttribute([NotNull] string format) + { + Format = format; + } + + [NotNull] public string Format { get; } + } + + /// + /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter + /// is an MVC action. If applied to a method, the MVC action name is calculated + /// implicitly from the context. Use this attribute for custom wrappers similar to + /// System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)] + public sealed class AspMvcActionAttribute : Attribute + { + public AspMvcActionAttribute() { } + + public AspMvcActionAttribute([NotNull] string anonymousProperty) + { + AnonymousProperty = anonymousProperty; + } + + [CanBeNull] public string AnonymousProperty { get; } + } + + /// + /// ASP.NET MVC attribute. Indicates that the marked parameter is an MVC area. + /// Use this attribute for custom wrappers similar to + /// System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)] + public sealed class AspMvcAreaAttribute : Attribute + { + public AspMvcAreaAttribute() { } + + public AspMvcAreaAttribute([NotNull] string anonymousProperty) + { + AnonymousProperty = anonymousProperty; + } + + [CanBeNull] public string AnonymousProperty { get; } + } + + /// + /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter is + /// an MVC controller. If applied to a method, the MVC controller name is calculated + /// implicitly from the context. Use this attribute for custom wrappers similar to + /// System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String, String). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)] + public sealed class AspMvcControllerAttribute : Attribute + { + public AspMvcControllerAttribute() { } + + public AspMvcControllerAttribute([NotNull] string anonymousProperty) + { + AnonymousProperty = anonymousProperty; + } + + [CanBeNull] public string AnonymousProperty { get; } + } + + /// + /// ASP.NET MVC attribute. Indicates that the marked parameter is an MVC Master. Use this attribute + /// for custom wrappers similar to System.Web.Mvc.Controller.View(String, String). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)] + public sealed class AspMvcMasterAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. Indicates that the marked parameter is an MVC model type. Use this attribute + /// for custom wrappers similar to System.Web.Mvc.Controller.View(String, Object). + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class AspMvcModelTypeAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter is an MVC + /// partial view. If applied to a method, the MVC partial view name is calculated implicitly + /// from the context. Use this attribute for custom wrappers similar to + /// System.Web.Mvc.Html.RenderPartialExtensions.RenderPartial(HtmlHelper, String). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)] + public sealed class AspMvcPartialViewAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. Allows disabling inspections for MVC views within a class or a method. + /// + [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)] + public sealed class AspMvcSuppressViewErrorAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. Indicates that a parameter is an MVC display template. + /// Use this attribute for custom wrappers similar to + /// System.Web.Mvc.Html.DisplayExtensions.DisplayForModel(HtmlHelper, String). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)] + public sealed class AspMvcDisplayTemplateAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. Indicates that the marked parameter is an MVC editor template. + /// Use this attribute for custom wrappers similar to + /// System.Web.Mvc.Html.EditorExtensions.EditorForModel(HtmlHelper, String). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)] + public sealed class AspMvcEditorTemplateAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. Indicates that the marked parameter is an MVC template. + /// Use this attribute for custom wrappers similar to + /// System.ComponentModel.DataAnnotations.UIHintAttribute(System.String). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)] + public sealed class AspMvcTemplateAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter + /// is an MVC view component. If applied to a method, the MVC view name is calculated implicitly + /// from the context. Use this attribute for custom wrappers similar to + /// System.Web.Mvc.Controller.View(Object). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)] + public sealed class AspMvcViewAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter + /// is an MVC view component name. + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)] + public sealed class AspMvcViewComponentAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter + /// is an MVC view component view. If applied to a method, the MVC view component view name is default. + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)] + public sealed class AspMvcViewComponentViewAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. When applied to a parameter of an attribute, + /// indicates that this parameter is an MVC action name. + /// + /// + /// [ActionName("Foo")] + /// public ActionResult Login(string returnUrl) { + /// ViewBag.ReturnUrl = Url.Action("Foo"); // OK + /// return RedirectToAction("Bar"); // Error: Cannot resolve action + /// } + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property)] + public sealed class AspMvcActionSelectorAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.Field)] + public sealed class HtmlElementAttributesAttribute : Attribute + { + public HtmlElementAttributesAttribute() { } + + public HtmlElementAttributesAttribute([NotNull] string name) + { + Name = name; + } + + [CanBeNull] public string Name { get; } + } + + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)] + public sealed class HtmlAttributeValueAttribute : Attribute + { + public HtmlAttributeValueAttribute([NotNull] string name) + { + Name = name; + } + + [NotNull] public string Name { get; } + } + + /// + /// Razor attribute. Indicates that the marked parameter or method is a Razor section. + /// Use this attribute for custom wrappers similar to + /// System.Web.WebPages.WebPageBase.RenderSection(String). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)] + public sealed class RazorSectionAttribute : Attribute { } + + /// + /// Indicates how method, constructor invocation, or property access + /// over collection type affects the contents of the collection. + /// Use to specify the access type. + /// + /// + /// Using this attribute only makes sense if all collection methods are marked with this attribute. + /// + /// + /// public class MyStringCollection : List<string> + /// { + /// [CollectionAccess(CollectionAccessType.Read)] + /// public string GetFirstString() + /// { + /// return this.ElementAt(0); + /// } + /// } + /// class Test + /// { + /// public void Foo() + /// { + /// // Warning: Contents of the collection is never updated + /// var col = new MyStringCollection(); + /// string x = col.GetFirstString(); + /// } + /// } + /// + [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Property)] + public sealed class CollectionAccessAttribute : Attribute + { + public CollectionAccessAttribute(CollectionAccessType collectionAccessType) + { + CollectionAccessType = collectionAccessType; + } + + public CollectionAccessType CollectionAccessType { get; } + } + + /// + /// Provides a value for the to define + /// how the collection method invocation affects the contents of the collection. + /// + [Flags] + public enum CollectionAccessType + { + /// Method does not use or modify content of the collection. + None = 0, + /// Method only reads content of the collection but does not modify it. + Read = 1, + /// Method can change content of the collection but does not add new elements. + ModifyExistingContent = 2, + /// Method can add new elements to the collection. + UpdatedContent = ModifyExistingContent | 4 + } + + /// + /// Indicates that the marked method is assertion method, i.e. it halts the control flow if + /// one of the conditions is satisfied. To set the condition, mark one of the parameters with + /// attribute. + /// + [AttributeUsage(AttributeTargets.Method)] + public sealed class AssertionMethodAttribute : Attribute { } + + /// + /// Indicates the condition parameter of the assertion method. The method itself should be + /// marked by attribute. The mandatory argument of + /// the attribute is the assertion type. + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class AssertionConditionAttribute : Attribute + { + public AssertionConditionAttribute(AssertionConditionType conditionType) + { + ConditionType = conditionType; + } + + public AssertionConditionType ConditionType { get; } + } + + /// + /// Specifies assertion type. If the assertion method argument satisfies the condition, + /// then the execution continues. Otherwise, execution is assumed to be halted. + /// + public enum AssertionConditionType + { + /// Marked parameter should be evaluated to true. + IS_TRUE = 0, + /// Marked parameter should be evaluated to false. + IS_FALSE = 1, + /// Marked parameter should be evaluated to null value. + IS_NULL = 2, + /// Marked parameter should be evaluated to not null value. + IS_NOT_NULL = 3, + } + + /// + /// Indicates that the marked method unconditionally terminates control flow execution. + /// For example, it could unconditionally throw exception. + /// + [Obsolete("Use [ContractAnnotation('=> halt')] instead")] + [AttributeUsage(AttributeTargets.Method)] + public sealed class TerminatesProgramAttribute : Attribute { } + + /// + /// Indicates that method is pure LINQ method, with postponed enumeration (like Enumerable.Select, + /// .Where). This annotation allows inference of [InstantHandle] annotation for parameters + /// of delegate type by analyzing LINQ method chains. + /// + [AttributeUsage(AttributeTargets.Method)] + public sealed class LinqTunnelAttribute : Attribute { } + + /// + /// Indicates that IEnumerable passed as a parameter is not enumerated. + /// Use this annotation to suppress the 'Possible multiple enumeration of IEnumerable' inspection. + /// + /// + /// static void ThrowIfNull<T>([NoEnumeration] T v, string n) where T : class + /// { + /// // custom check for null but no enumeration + /// } + /// + /// void Foo(IEnumerable<string> values) + /// { + /// ThrowIfNull(values, nameof(values)); + /// var x = values.ToList(); // No warnings about multiple enumeration + /// } + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class NoEnumerationAttribute : Attribute { } + + /// + /// Indicates that the marked parameter is a regular expression pattern. + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)] + public sealed class RegexPatternAttribute : Attribute { } + + /// + /// Prevents the Member Reordering feature from tossing members of the marked class. + /// + /// + /// The attribute must be mentioned in your member reordering patterns. + /// + [AttributeUsage( + AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.Struct | AttributeTargets.Enum)] + public sealed class NoReorderAttribute : Attribute { } + + /// + /// XAML attribute. Indicates the type that has ItemsSource property and should be treated + /// as ItemsControl-derived type, to enable inner items DataContext type resolve. + /// + [AttributeUsage(AttributeTargets.Class)] + public sealed class XamlItemsControlAttribute : Attribute { } + + /// + /// XAML attribute. Indicates the property of some BindingBase-derived type, that + /// is used to bind some item of ItemsControl-derived type. This annotation will + /// enable the DataContext type resolve for XAML bindings for such properties. + /// + /// + /// Property should have the tree ancestor of the ItemsControl type or + /// marked with the attribute. + /// + [AttributeUsage(AttributeTargets.Property)] + public sealed class XamlItemBindingOfItemsControlAttribute : Attribute { } + + /// + /// XAML attribute. Indicates the property of some Style-derived type, that + /// is used to style items of ItemsControl-derived type. This annotation will + /// enable the DataContext type resolve for XAML bindings for such properties. + /// + /// + /// Property should have the tree ancestor of the ItemsControl type or + /// marked with the attribute. + /// + [AttributeUsage(AttributeTargets.Property)] + public sealed class XamlItemStyleOfItemsControlAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)] + public sealed class AspChildControlTypeAttribute : Attribute + { + public AspChildControlTypeAttribute([NotNull] string tagName, [NotNull] Type controlType) + { + TagName = tagName; + ControlType = controlType; + } + + [NotNull] public string TagName { get; } + + [NotNull] public Type ControlType { get; } + } + + [AttributeUsage(AttributeTargets.Property | AttributeTargets.Method)] + public sealed class AspDataFieldAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Property | AttributeTargets.Method)] + public sealed class AspDataFieldsAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Property)] + public sealed class AspMethodPropertyAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)] + public sealed class AspRequiredAttributeAttribute : Attribute + { + public AspRequiredAttributeAttribute([NotNull] string attribute) + { + Attribute = attribute; + } + + [NotNull] public string Attribute { get; } + } + + [AttributeUsage(AttributeTargets.Property)] + public sealed class AspTypePropertyAttribute : Attribute + { + public bool CreateConstructorReferences { get; } + + public AspTypePropertyAttribute(bool createConstructorReferences) + { + CreateConstructorReferences = createConstructorReferences; + } + } + + [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] + public sealed class RazorImportNamespaceAttribute : Attribute + { + public RazorImportNamespaceAttribute([NotNull] string name) + { + Name = name; + } + + [NotNull] public string Name { get; } + } + + [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] + public sealed class RazorInjectionAttribute : Attribute + { + public RazorInjectionAttribute([NotNull] string type, [NotNull] string fieldName) + { + Type = type; + FieldName = fieldName; + } + + [NotNull] public string Type { get; } + + [NotNull] public string FieldName { get; } + } + + [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] + public sealed class RazorDirectiveAttribute : Attribute + { + public RazorDirectiveAttribute([NotNull] string directive) + { + Directive = directive; + } + + [NotNull] public string Directive { get; } + } + + [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] + public sealed class RazorPageBaseTypeAttribute : Attribute + { + public RazorPageBaseTypeAttribute([NotNull] string baseType) + { + BaseType = baseType; + } + public RazorPageBaseTypeAttribute([NotNull] string baseType, string pageName) + { + BaseType = baseType; + PageName = pageName; + } + + [NotNull] public string BaseType { get; } + [CanBeNull] public string PageName { get; } + } + + [AttributeUsage(AttributeTargets.Method)] + public sealed class RazorHelperCommonAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Property)] + public sealed class RazorLayoutAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Method)] + public sealed class RazorWriteLiteralMethodAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Method)] + public sealed class RazorWriteMethodAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class RazorWriteMethodParameterAttribute : Attribute { } +} \ No newline at end of file diff --git a/CourierPrime-Regular.ttf b/CourierPrime-Regular.ttf new file mode 100644 index 0000000000000000000000000000000000000000..4f638f6992274404f825f3f943bb1d21b02888c2 GIT binary patch literal 68128 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®noDRk&?P2sT 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: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 Zml!TZoI3*L5^T`t!ca@8AE_7F{|CV3TfqPT literal 0 HcmV?d00001 diff --git a/MainWindow.xaml b/MainWindow.xaml index 3ca06e5..695aaf9 100644 --- a/MainWindow.xaml +++ b/MainWindow.xaml @@ -13,42 +13,58 @@ + + -