Repository: astenlund/fs2ff Branch: master Commit: cad104f7be06 Files: 46 Total size: 146.0 KB Directory structure: gitextract_pdi8_1c4/ ├── .editorconfig ├── .github/ │ └── dependabot.yml ├── .gitignore ├── .vscode/ │ ├── launch.json │ └── tasks.json ├── ActionCommand.cs ├── Annotations.cs ├── App.xaml ├── App.xaml.cs ├── AssemblyInfo.cs ├── Behaviors/ │ ├── MoveFocusOnEnterBehavior.cs │ └── UpdateSourceOnLostFocusBehavior.cs ├── Converters/ │ ├── BooleanToDoubleConverter.cs │ ├── BooleanToVisibilityConverter.cs │ ├── FormatStringConverter.cs │ ├── InvertedBooleanConverter.cs │ ├── IpAddressToStringConverter.cs │ └── UIntToDoubleConverter.cs ├── DataSender.cs ├── Extensions.cs ├── FodyWeavers.xml ├── FodyWeavers.xsd ├── IpDetectionService.cs ├── LICENSE ├── MainViewModel.cs ├── MainWindow.xaml ├── MainWindow.xaml.cs ├── Models/ │ ├── Attitude.cs │ ├── Position.cs │ └── Traffic.cs ├── Preferences.Designer.cs ├── Preferences.settings ├── README.md ├── Resources.xaml ├── SimConnect/ │ ├── DEFINITION.cs │ ├── EVENT.cs │ ├── ISimConnectMessageHandler.cs │ ├── REQUEST.cs │ └── SimConnectAdapter.cs ├── UpdateChecker.cs ├── UpdateInformation.cs ├── ViewModelLocator.cs ├── fs2ff.csproj ├── fs2ff.sln ├── global.json └── publish.ps1 ================================================ FILE CONTENTS ================================================ ================================================ FILE: .editorconfig ================================================ # Remove the line below if you want to inherit .editorconfig settings from higher directories root = true # ReSharper annotations [Annotations.cs] dotnet_diagnostic.CS8618.severity = none # All files [*.*] max_line_length=160 # C# files [*.cs] #### Core EditorConfig Options #### # Indentation and spacing indent_size = 4 indent_style = space tab_width = 4 # New line preferences end_of_line = crlf insert_final_newline = true #### .NET Coding Conventions #### # Organize usings dotnet_separate_import_directive_groups = false dotnet_sort_system_directives_first = false file_header_template = unset # this. and Me. preferences dotnet_style_qualification_for_event = false:silent dotnet_style_qualification_for_field = false:silent dotnet_style_qualification_for_method = false:silent dotnet_style_qualification_for_property = false:silent # Language keywords vs BCL types preferences dotnet_style_predefined_type_for_locals_parameters_members = true:silent dotnet_style_predefined_type_for_member_access = true:silent # Parentheses preferences dotnet_style_parentheses_in_arithmetic_binary_operators = always_for_clarity:silent dotnet_style_parentheses_in_other_binary_operators = always_for_clarity:silent dotnet_style_parentheses_in_other_operators = never_if_unnecessary:silent dotnet_style_parentheses_in_relational_binary_operators = always_for_clarity:silent # Modifier preferences dotnet_style_require_accessibility_modifiers = for_non_interface_members:silent # Expression-level preferences dotnet_style_coalesce_expression = true:suggestion dotnet_style_collection_initializer = true:suggestion dotnet_style_explicit_tuple_names = true:suggestion dotnet_style_null_propagation = true:suggestion dotnet_style_object_initializer = true:suggestion dotnet_style_operator_placement_when_wrapping = beginning_of_line dotnet_style_prefer_auto_properties = true:silent dotnet_style_prefer_compound_assignment = true:suggestion dotnet_style_prefer_conditional_expression_over_assignment = true:silent dotnet_style_prefer_conditional_expression_over_return = true:silent dotnet_style_prefer_inferred_anonymous_type_member_names = true:suggestion dotnet_style_prefer_inferred_tuple_names = true:suggestion dotnet_style_prefer_is_null_check_over_reference_equality_method = true:suggestion dotnet_style_prefer_simplified_boolean_expressions = true:suggestion dotnet_style_prefer_simplified_interpolation = true:suggestion # Field preferences dotnet_style_readonly_field = true:suggestion # Parameter preferences dotnet_code_quality_unused_parameters = all:suggestion #### C# Coding Conventions #### # var preferences csharp_style_var_elsewhere = false:silent csharp_style_var_for_built_in_types = false:silent csharp_style_var_when_type_is_apparent = false:silent # Expression-bodied members csharp_style_expression_bodied_accessors = true:silent csharp_style_expression_bodied_constructors = false:silent csharp_style_expression_bodied_indexers = true:silent csharp_style_expression_bodied_lambdas = true:silent csharp_style_expression_bodied_local_functions = false:silent csharp_style_expression_bodied_methods = false:silent csharp_style_expression_bodied_operators = false:silent csharp_style_expression_bodied_properties = true:silent # Pattern matching preferences csharp_style_pattern_matching_over_as_with_null_check = true:suggestion csharp_style_pattern_matching_over_is_with_cast_check = true:suggestion csharp_style_prefer_switch_expression = true:suggestion # Null-checking preferences csharp_style_conditional_delegate_call = true:suggestion # Modifier preferences csharp_prefer_static_local_function = true:suggestion csharp_preferred_modifier_order = public,private,protected,internal,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,volatile,async:silent # Code-block preferences csharp_prefer_braces = true:silent csharp_prefer_simple_using_statement = true:suggestion # Expression-level preferences csharp_prefer_simple_default_expression = true:suggestion csharp_style_deconstructed_variable_declaration = true:suggestion csharp_style_inlined_variable_declaration = true:suggestion csharp_style_pattern_local_over_anonymous_function = true:suggestion csharp_style_prefer_index_operator = true:suggestion csharp_style_prefer_range_operator = true:suggestion csharp_style_throw_expression = true:suggestion csharp_style_unused_value_assignment_preference = discard_variable:suggestion csharp_style_unused_value_expression_statement_preference = discard_variable:silent # 'using' directive preferences csharp_using_directive_placement = outside_namespace:silent #### C# Formatting Rules #### # New line preferences csharp_new_line_before_catch = true csharp_new_line_before_else = true csharp_new_line_before_finally = true csharp_new_line_before_members_in_anonymous_types = true csharp_new_line_before_members_in_object_initializers = true csharp_new_line_before_open_brace = all csharp_new_line_between_query_expression_clauses = true # Indentation preferences csharp_indent_block_contents = true csharp_indent_braces = false csharp_indent_case_contents = true csharp_indent_case_contents_when_block = true csharp_indent_labels = one_less_than_current csharp_indent_switch_labels = true # Space preferences csharp_space_after_cast = false csharp_space_after_colon_in_inheritance_clause = true csharp_space_after_comma = true csharp_space_after_dot = false csharp_space_after_keywords_in_control_flow_statements = true csharp_space_after_semicolon_in_for_statement = true csharp_space_around_binary_operators = before_and_after csharp_space_around_declaration_statements = false csharp_space_before_colon_in_inheritance_clause = true csharp_space_before_comma = false csharp_space_before_dot = false csharp_space_before_open_square_brackets = false csharp_space_before_semicolon_in_for_statement = false csharp_space_between_empty_square_brackets = false csharp_space_between_method_call_empty_parameter_list_parentheses = false csharp_space_between_method_call_name_and_opening_parenthesis = false csharp_space_between_method_call_parameter_list_parentheses = false csharp_space_between_method_declaration_empty_parameter_list_parentheses = false csharp_space_between_method_declaration_name_and_open_parenthesis = false csharp_space_between_method_declaration_parameter_list_parentheses = false csharp_space_between_parentheses = false csharp_space_between_square_brackets = false # Wrapping preferences csharp_preserve_single_line_blocks = true csharp_preserve_single_line_statements = true #### Naming styles #### # Naming rules # Symbol specifications # Naming styles ================================================ FILE: .github/dependabot.yml ================================================ # To get started with Dependabot version updates, you'll need to specify which # package ecosystems to update and where the package manifests are located. # Please see the documentation for all configuration options: # https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates version: 2 updates: - package-ecosystem: "nuget" directory: "/" schedule: interval: "daily" rebase-strategy: "auto" reviewers: - "astenlund" assignees: - "astenlund" ================================================ FILE: .gitignore ================================================ ## Ignore Visual Studio temporary files, build results, and ## files generated by popular Visual Studio add-ons. ## ## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore # Image files *.png # Libraries lib/* # Published binaries publish/* # User-specific files *.rsuser *.suo *.user *.userosscache *.sln.docstates # User-specific files (MonoDevelop/Xamarin Studio) *.userprefs # Mono auto generated files mono_crash.* # Build results [Dd]ebug/ [Dd]ebugPublic/ [Rr]elease/ [Rr]eleases/ x64/ x86/ [Aa][Rr][Mm]/ [Aa][Rr][Mm]64/ bld/ [Bb]in/ [Oo]bj/ [Ll]og/ # Visual Studio 2015/2017 cache/options directory .vs/ # Uncomment if you have tasks that create the project's static files in wwwroot #wwwroot/ # Visual Studio 2017 auto generated files Generated\ Files/ # MSTest test Results [Tt]est[Rr]esult*/ [Bb]uild[Ll]og.* # NUNIT *.VisualState.xml TestResult.xml # Build Results of an ATL Project [Dd]ebugPS/ [Rr]eleasePS/ dlldata.c # Benchmark Results BenchmarkDotNet.Artifacts/ # .NET Core project.lock.json project.fragment.lock.json artifacts/ # StyleCop StyleCopReport.xml # Files built by Visual Studio *_i.c *_p.c *_h.h *.ilk *.meta *.obj *.iobj *.pch *.pdb *.ipdb *.pgc *.pgd *.rsp *.sbr *.tlb *.tli *.tlh *.tmp *.tmp_proj *_wpftmp.csproj *.log *.vspscc *.vssscc .builds *.pidb *.svclog *.scc # Chutzpah Test files _Chutzpah* # Visual C++ cache files ipch/ *.aps *.ncb *.opendb *.opensdf *.sdf *.cachefile *.VC.db *.VC.VC.opendb # Visual Studio profiler *.psess *.vsp *.vspx *.sap # Visual Studio Trace Files *.e2e # TFS 2012 Local Workspace $tf/ # Guidance Automation Toolkit *.gpState # ReSharper is a .NET coding add-in _ReSharper*/ *.[Rr]e[Ss]harper *.DotSettings.user # JustCode is a .NET coding add-in .JustCode # TeamCity is a build add-in _TeamCity* # DotCover is a Code Coverage Tool *.dotCover # AxoCover is a Code Coverage Tool .axoCover/* !.axoCover/settings.json # Visual Studio code coverage results *.coverage *.coveragexml # NCrunch _NCrunch_* .*crunch*.local.xml nCrunchTemp_* # MightyMoose *.mm.* AutoTest.Net/ # Web workbench (sass) .sass-cache/ # Installshield output folder [Ee]xpress/ # DocProject is a documentation generator add-in DocProject/buildhelp/ DocProject/Help/*.HxT DocProject/Help/*.HxC DocProject/Help/*.hhc DocProject/Help/*.hhk DocProject/Help/*.hhp DocProject/Help/Html2 DocProject/Help/html # Click-Once directory publish/ # Publish Web Output *.[Pp]ublish.xml *.azurePubxml # Note: Comment the next line if you want to checkin your web deploy settings, # but database connection strings (with potential passwords) will be unencrypted *.pubxml *.publishproj # Microsoft Azure Web App publish settings. Comment the next line if you want to # checkin your Azure Web App publish settings, but sensitive information contained # in these scripts will be unencrypted PublishScripts/ # NuGet Packages *.nupkg # The packages folder can be ignored because of Package Restore **/[Pp]ackages/* # except build/, which is used as an MSBuild target. !**/[Pp]ackages/build/ # Uncomment if necessary however generally it will be regenerated when needed #!**/[Pp]ackages/repositories.config # NuGet v3's project.json files produces more ignorable files *.nuget.props *.nuget.targets # Microsoft Azure Build Output csx/ *.build.csdef # Microsoft Azure Emulator ecf/ rcf/ # Windows Store app package directories and files AppPackages/ BundleArtifacts/ Package.StoreAssociation.xml _pkginfo.txt *.appx *.appxbundle *.appxupload # Visual Studio cache files # files ending in .cache can be ignored *.[Cc]ache # but keep track of directories ending in .cache !?*.[Cc]ache/ # Others ClientBin/ ~$* *~ *.dbmdl *.dbproj.schemaview *.jfm *.pfx *.publishsettings orleans.codegen.cs # Including strong name files can present a security risk # (https://github.com/github/gitignore/pull/2483#issue-259490424) #*.snk # Since there are multiple workflows, uncomment next line to ignore bower_components # (https://github.com/github/gitignore/pull/1529#issuecomment-104372622) #bower_components/ # RIA/Silverlight projects Generated_Code/ # Backup & report files from converting an old project file # to a newer Visual Studio version. Backup files are not needed, # because we have git ;-) _UpgradeReport_Files/ Backup*/ UpgradeLog*.XML UpgradeLog*.htm ServiceFabricBackup/ *.rptproj.bak # SQL Server files *.mdf *.ldf *.ndf # Business Intelligence projects *.rdl.data *.bim.layout *.bim_*.settings *.rptproj.rsuser *- Backup*.rdl # Microsoft Fakes FakesAssemblies/ # GhostDoc plugin setting file *.GhostDoc.xml # Node.js Tools for Visual Studio .ntvs_analysis.dat node_modules/ # Visual Studio 6 build log *.plg # Visual Studio 6 workspace options file *.opt # Visual Studio 6 auto-generated workspace file (contains which files were open etc.) *.vbw # Visual Studio LightSwitch build output **/*.HTMLClient/GeneratedArtifacts **/*.DesktopClient/GeneratedArtifacts **/*.DesktopClient/ModelManifest.xml **/*.Server/GeneratedArtifacts **/*.Server/ModelManifest.xml _Pvt_Extensions # Paket dependency manager .paket/paket.exe paket-files/ # FAKE - F# Make .fake/ # CodeRush personal settings .cr/personal # Python Tools for Visual Studio (PTVS) __pycache__/ *.pyc # Cake - Uncomment if you are using it # tools/** # !tools/packages.config # Tabs Studio *.tss # Telerik's JustMock configuration file *.jmconfig # BizTalk build output *.btp.cs *.btm.cs *.odx.cs *.xsd.cs # OpenCover UI analysis results OpenCover/ # Azure Stream Analytics local run output ASALocalRun/ # MSBuild Binary and Structured Log *.binlog # NVidia Nsight GPU debugger configuration file *.nvuser # MFractors (Xamarin productivity tool) working folder .mfractor/ # Local History for Visual Studio .localhistory/ # BeatPulse healthcheck temp database healthchecksdb # Backup folder for Package Reference Convert tool in Visual Studio 2017 MigrationBackup/ ## ## Visual studio for Mac ## # globs Makefile.in *.userprefs *.usertasks config.make config.status aclocal.m4 install-sh autom4te.cache/ *.tar.gz tarballs/ test-results/ # Mac bundle stuff *.dmg *.app # content below from: https://github.com/github/gitignore/blob/master/Global/macOS.gitignore # General .DS_Store .AppleDouble .LSOverride # Icon must end with two \r Icon # Thumbnails ._* # Files that might appear in the root of a volume .DocumentRevisions-V100 .fseventsd .Spotlight-V100 .TemporaryItems .Trashes .VolumeIcon.icns .com.apple.timemachine.donotpresent # Directories potentially created on remote AFP share .AppleDB .AppleDesktop Network Trash Folder Temporary Items .apdisk # content below from: https://github.com/github/gitignore/blob/master/Global/Windows.gitignore # Windows thumbnail cache files Thumbs.db ehthumbs.db ehthumbs_vista.db # Dump file *.stackdump # Folder config file [Dd]esktop.ini # Recycle Bin used on file shares $RECYCLE.BIN/ # Windows Installer files *.cab *.msi *.msix *.msm *.msp # Windows shortcuts *.lnk # JetBrains Rider .idea/ *.sln.iml ## ## Visual Studio Code ## .vscode/* !.vscode/settings.json !.vscode/tasks.json !.vscode/launch.json !.vscode/extensions.json ================================================ FILE: .vscode/launch.json ================================================ { "version": "0.2.0", "configurations": [ { // Use IntelliSense to find out which attributes exist for C# debugging // Use hover for the description of the existing attributes // For further information visit https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md "name": ".NET Core Launch (console)", "type": "coreclr", "request": "launch", "preLaunchTask": "build", // If you have changed target frameworks, make sure to update the program path. "program": "${workspaceFolder}/bin/Debug/netcoreapp3.1/win-x64/fs2ff.exe", "args": [], "cwd": "${workspaceFolder}", // For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console "console": "internalConsole", "stopAtEntry": false }, { "name": ".NET Core Attach", "type": "coreclr", "request": "attach" } ] } ================================================ FILE: .vscode/tasks.json ================================================ { "version": "2.0.0", "tasks": [ { "label": "build", "command": "dotnet", "type": "process", "args": [ "build", "${workspaceFolder}/fs2ff.csproj", "/property:GenerateFullPaths=true", "/consoleloggerparameters:NoSummary" ], "problemMatcher": "$msCompile" }, { "label": "publish", "command": "dotnet", "type": "process", "args": [ "publish", "${workspaceFolder}/fs2ff.csproj", "/property:GenerateFullPaths=true", "/consoleloggerparameters:NoSummary" ], "problemMatcher": "$msCompile" }, { "label": "watch", "command": "dotnet", "type": "process", "args": [ "watch", "run", "${workspaceFolder}/fs2ff.csproj", "/property:GenerateFullPaths=true", "/consoleloggerparameters:NoSummary" ], "problemMatcher": "$msCompile" } ] } ================================================ FILE: ActionCommand.cs ================================================ // ReSharper disable UnusedMember.Global // ReSharper disable UnusedType.Global using System; using System.Windows.Input; namespace fs2ff { public class ActionCommand : ICommand { private readonly Action _action; private readonly Func _predicate; public ActionCommand() { _action = () => { }; _predicate = () => true; } public ActionCommand(Action action) { _action = action; _predicate = () => true; } public ActionCommand(Action action, Func predicate) { _action = action; _predicate = predicate; } public event EventHandler? CanExecuteChanged; public bool CanExecute(object? _) => _predicate(); public void Execute(object? parameter) => _action(); public void TriggerCanExecuteChanged() => CanExecuteChanged?.Invoke(this, new EventArgs()); } public class ActionCommand : ICommand where T : struct { private readonly Action _action; private readonly Func _predicate; public ActionCommand() { _action = _ => { }; _predicate = _ => true; } public ActionCommand(Action action) { _action = action; _predicate = _ => true; } public ActionCommand(Action action, Func predicate) { _action = action; _predicate = predicate; } public event EventHandler? CanExecuteChanged; public bool CanExecute(object? parameter) => parameter is T param ? _predicate(param) : _predicate(null); public void Execute(object? parameter) { if (parameter is T param) _action(param); else _action(null); } public void TriggerCanExecuteChanged() => CanExecuteChanged?.Invoke(this, new EventArgs()); } } ================================================ FILE: Annotations.cs ================================================ /* 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 fs2ff.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 { } } ================================================ FILE: App.xaml ================================================  ================================================ FILE: App.xaml.cs ================================================ using System; using System.Reflection; using System.Windows; using fs2ff.SimConnect; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Hosting; namespace fs2ff { /// /// Interaction logic for App.xaml /// public partial class App { private static readonly IHost Host = new HostBuilder() .ConfigureServices(ConfigureServices) .Build(); protected override async void OnExit(ExitEventArgs e) { await Host.StopAsync(TimeSpan.FromSeconds(3)); Host.Dispose(); base.OnExit(e); } protected override async void OnStartup(StartupEventArgs e) { await Host.StartAsync(); base.OnStartup(e); } public static Version AssemblyVersion => Assembly.GetEntryAssembly()!.GetName().Version!; public static string InformationalVersion => "v" + (Assembly .GetEntryAssembly()? .GetCustomAttribute()? .InformationalVersion ?? "0.0.0"); public static T GetRequiredService() where T : class => Host.Services.GetRequiredService(); public static void ConfigureServices(IServiceCollection services) { services.AddSingleton(); services.AddSingleton(); services.AddSingleton(); services.AddSingleton(); services.AddHostedService(provider => provider.GetRequiredService()); } } } ================================================ FILE: AssemblyInfo.cs ================================================ using System.Windows; [assembly:ThemeInfo( ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located //(used if a resource is not found in the page, // or application resource dictionaries) ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located //(used if a resource is not found in the page, // app, or any theme specific resource dictionaries) )] ================================================ FILE: Behaviors/MoveFocusOnEnterBehavior.cs ================================================ using System.Windows; using System.Windows.Input; using Microsoft.Xaml.Behaviors; namespace fs2ff.Behaviors { public class MoveFocusOnEnterBehavior : Behavior { protected override void OnAttached() { base.OnAttached(); if (AssociatedObject != null) AssociatedObject.KeyDown += AssociatedObject_KeyDown; } protected override void OnDetaching() { if (AssociatedObject != null) AssociatedObject.KeyDown -= AssociatedObject_KeyDown; base.OnDetaching(); } private static void AssociatedObject_KeyDown(object sender, KeyEventArgs e) { if (sender is UIElement element && e.Key == Key.Return) element.MoveFocus(new TraversalRequest(FocusNavigationDirection.Next)); } } } ================================================ FILE: Behaviors/UpdateSourceOnLostFocusBehavior.cs ================================================ using System.Windows; using System.Windows.Controls; using System.Windows.Data; using Microsoft.Xaml.Behaviors; namespace fs2ff.Behaviors { public class UpdateSourceOnLostFocusBehavior : Behavior { protected override void OnAttached() { base.OnAttached(); if (AssociatedObject != null) AssociatedObject.LostFocus += AssociatedObject_LostFocus; } protected override void OnDetaching() { if (AssociatedObject != null) AssociatedObject.LostFocus -= AssociatedObject_LostFocus; base.OnDetaching(); } private static void AssociatedObject_LostFocus(object sender, RoutedEventArgs e) { if (sender is TextBox textBox) BindingOperations.GetBindingExpression(textBox, TextBox.TextProperty)?.UpdateSource(); } } } ================================================ FILE: Converters/BooleanToDoubleConverter.cs ================================================ using System; using System.Globalization; using System.Linq; using System.Windows.Data; using System.Windows.Markup; namespace fs2ff.Converters { public class BooleanToDoubleConverter : MarkupExtension, IValueConverter { public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { if (!(value is bool val)) throw new InvalidOperationException($"{nameof(value)} must be a {nameof(Boolean)}"); var doubles = parameter.ToString()?.Split(',').Select(double.Parse).ToArray() ?? new double[0]; if (doubles.Length != 2) throw new InvalidOperationException($"{nameof(parameter)} must be two comma-separated integer values"); return val ? doubles[0] : doubles[1]; } public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) { throw new NotImplementedException(); } public override object ProvideValue(IServiceProvider serviceProvider) { return this; } } } ================================================ FILE: Converters/BooleanToVisibilityConverter.cs ================================================ using System; using System.Globalization; using System.Windows; using System.Windows.Data; using System.Windows.Markup; namespace fs2ff.Converters { public class BooleanToVisibilityConverter : MarkupExtension, IValueConverter { public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { return value is bool visible && visible ? Visibility.Visible : parameter is Visibility vis ? vis : Visibility.Collapsed; } public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) { return value is Visibility vis ? vis == Visibility.Visible : Binding.DoNothing; } public override object ProvideValue(IServiceProvider serviceProvider) { return this; } } } ================================================ FILE: Converters/FormatStringConverter.cs ================================================ using System; using System.Globalization; using System.Windows.Data; using System.Windows.Markup; namespace fs2ff.Converters { public class FormatStringConverter : MarkupExtension, IValueConverter { public object Convert(object value, Type targetType, object? parameter, CultureInfo culture) { return parameter is string format ? string.Format(format, value) : value; } public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) { throw new NotImplementedException(); } public override object ProvideValue(IServiceProvider serviceProvider) { return this; } } } ================================================ FILE: Converters/InvertedBooleanConverter.cs ================================================ using System; using System.Globalization; using System.Windows.Data; using System.Windows.Markup; namespace fs2ff.Converters { public class InvertedBooleanConverter : MarkupExtension, IValueConverter { public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { return !(bool)value; } public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) { return !(bool)value; } public override object ProvideValue(IServiceProvider serviceProvider) { return this; } } } ================================================ FILE: Converters/IpAddressToStringConverter.cs ================================================ using System; using System.Globalization; using System.Net; using System.Text.RegularExpressions; using System.Windows.Data; using System.Windows.Markup; namespace fs2ff.Converters { public class IpAddressToStringConverter : MarkupExtension, IValueConverter { private readonly Regex _regex = new Regex(@"^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$"); public object Convert(object? value, Type targetType, object parameter, CultureInfo culture) { if (!(value is IPAddress ip)) return ""; return Equals(ip, IPAddress.Any) ? "" : ip.ToString(); } public object? ConvertBack(object? value, Type targetType, object parameter, CultureInfo culture) { if (value == null) return null; if (!(value is string str)) return Binding.DoNothing; if (str == "") return null; if (!_regex.IsMatch(str)) return Binding.DoNothing; return IPAddress.TryParse(str, out var result) ? result : Binding.DoNothing; } public override object ProvideValue(IServiceProvider serviceProvider) { return this; } } } ================================================ FILE: Converters/UIntToDoubleConverter.cs ================================================ using System; using System.Globalization; using System.Windows.Data; using System.Windows.Markup; namespace fs2ff.Converters { public class UIntToDoubleConverter : MarkupExtension, IValueConverter { public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { return value is uint i ? (double)i : Binding.DoNothing; } public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) { return value is double d ? (int)Math.Round(d) : Binding.DoNothing; } public override object ProvideValue(IServiceProvider serviceProvider) { return this; } } } ================================================ FILE: DataSender.cs ================================================ using System; using System.Globalization; using System.Net; using System.Net.Sockets; using System.Text; using System.Threading.Tasks; using fs2ff.Models; namespace fs2ff { public class DataSender : IDisposable { private const int Port = 49002; private const string SimId = "MSFS"; private IPEndPoint? _endPoint; private Socket? _socket; public void Connect(IPAddress? ip) { Disconnect(); ip ??= IPAddress.Broadcast; _endPoint = new IPEndPoint(ip, Port); _socket = new Socket(_endPoint.Address.AddressFamily, SocketType.Dgram, ProtocolType.Udp) { EnableBroadcast = ip.Equals(IPAddress.Broadcast) }; } public void Disconnect() => _socket?.Dispose(); public void Dispose() => _socket?.Dispose(); public async Task Send(Attitude a) { var data = string.Format(CultureInfo.InvariantCulture, "XATT{0},{1:0.#},{2:0.#},{3:0.#},,,,,,,,,", // Garmin Pilot requires 13 fields SimId, a.TrueHeading, -a.Pitch, -a.Bank); await Send(data).ConfigureAwait(false); } public async Task Send(Position p) { var data = string.Format(CultureInfo.InvariantCulture, "XGPS{0},{1:0.#####},{2:0.#####},{3:0.#},{4:0.###},{5:0.#}", SimId, p.Longitude, p.Latitude, p.Altitude, p.GroundTrack, p.GroundSpeed); await Send(data).ConfigureAwait(false); } public async Task Send(Traffic t, uint id) { var data = string.Format(CultureInfo.InvariantCulture, "XTRAFFIC{0},{1},{2:0.#####},{3:0.#####},{4:0.#},{5:0.#},{6},{7:0.###},{8:0.#},{9}", SimId, id, t.Latitude, t.Longitude, t.Altitude, t.VerticalSpeed, t.OnGround ? 0 : 1, t.TrueHeading, t.GroundVelocity, TryGetFlightNumber(t) ?? t.TailNumber); await Send(data).ConfigureAwait(false); } private async Task Send(string data) { if (_endPoint != null && _socket != null) { await _socket .SendToAsync(new ArraySegment(Encoding.ASCII.GetBytes(data)), SocketFlags.None, _endPoint) .ConfigureAwait(false); } } private static string? TryGetFlightNumber(Traffic t) => !string.IsNullOrEmpty(t.Airline) && !string.IsNullOrEmpty(t.FlightNumber) ? $"{t.Airline} {t.FlightNumber}" : null; } } ================================================ FILE: Extensions.cs ================================================ using System; using System.Threading.Tasks; namespace fs2ff { public static class Extensions { public static T AdjustToBounds(this T value, T min, T max) where T : IComparable => value.CompareTo(min) < 0 ? min : value.CompareTo(max) > 0 ? max : value; public static async Task RaiseAsync(this Func? handler, T value) { if (handler == null) { return; } Delegate[] delegates = handler.GetInvocationList(); Task[] tasks = new Task[delegates.Length]; for (var i = 0; i < delegates.Length; i++) { tasks[i] = ((Func) delegates[i])(value); } await Task.WhenAll(tasks); } public static async Task RaiseAsync(this Func? handler, T1 value1, T2 value2) { if (handler == null) { return; } Delegate[] delegates = handler.GetInvocationList(); Task[] tasks = new Task[delegates.Length]; for (var i = 0; i < delegates.Length; i++) { tasks[i] = ((Func) delegates[i])(value1, value2); } await Task.WhenAll(tasks); } } } ================================================ FILE: FodyWeavers.xml ================================================  ================================================ FILE: FodyWeavers.xsd ================================================  Used to control if the On_PropertyName_Changed feature is enabled. Used to control if the Dependent properties feature is enabled. Used to control if the IsChanged property feature is enabled. Used to change the name of the method that fires the notify event. This is a string that accepts multiple values in a comma separated form. Used to control if equality checks should be inserted. If false, equality checking will be disabled for the project. Used to control if equality checks should use the Equals method resolved from the base class. Used to control if equality checks should use the static Equals method resolved from the base class. Used to turn off build warnings from this weaver. Used to turn off build warnings about mismatched On_PropertyName_Changed methods. 'true' to run assembly verification (PEVerify) on the target assembly after all weavers have been executed. A comma-separated list of error codes that can be safely ignored in assembly verification. 'false' to turn off automatic generation of the XML Schema file. ================================================ FILE: IpDetectionService.cs ================================================ using System; using System.Net; using System.Net.Sockets; using System.Text; using System.Text.Json; using System.Threading; using System.Threading.Tasks; using Microsoft.Extensions.Hosting; namespace fs2ff { public class IpDetectionService : IHostedService { private const int Port = 63093; public event Action? NewIpDetected; public async Task StartAsync(CancellationToken cancellationToken) { await Task.Run(async () => { try { using var udpClient = new UdpClient(Port, IPAddress.Any.AddressFamily); while (!cancellationToken.IsCancellationRequested) { var result = await udpClient.ReceiveAsync(); var text = Encoding.ASCII.GetString(result.Buffer); if (IsForeFlightGdl90(text)) { NewIpDetected?.Invoke(result.RemoteEndPoint.Address); } } } catch (SocketException e) { Console.Error.WriteLine(e); } }, cancellationToken); } public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask; private static bool IsForeFlightGdl90(string text) { try { return JsonDocument.Parse(text).RootElement.TryGetProperty("App", out var app) && app.GetString() == "ForeFlight"; } catch (Exception) { return false; } } } } ================================================ FILE: LICENSE ================================================ This is free and unencumbered software released into the public domain. Anyone is free to copy, modify, publish, use, compile, sell, or distribute this software, either in source code form or as a compiled binary, for any purpose, commercial or non-commercial, and by any means. In jurisdictions that recognize copyright laws, the author or authors of this software dedicate any and all copyright interest in the software to the public domain. We make this dedication for the benefit of the public at large and to the detriment of our heirs and successors. We intend this dedication to be an overt act of relinquishment in perpetuity of all present and future rights to this software under copyright law. 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 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. For more information, please refer to ================================================ FILE: MainViewModel.cs ================================================ using System; using System.ComponentModel; using System.Diagnostics; using System.Diagnostics.CodeAnalysis; using System.Net; using System.Threading.Tasks; using System.Windows.Input; using System.Windows.Threading; using fs2ff.Models; using fs2ff.SimConnect; #pragma warning disable 67 namespace fs2ff { [SuppressMessage("ReSharper", "NotAccessedField.Local", Justification = "DispatcherTimer field is kept to prevent premature GC")] public class MainViewModel : INotifyPropertyChanged, ISimConnectMessageHandler { private readonly DataSender _dataSender; private readonly SimConnectAdapter _simConnect; private readonly IpDetectionService _ipDetectionService; private readonly DispatcherTimer _ipHintTimer; private readonly DispatcherTimer _autoConnectTimer; private uint _attitudeFrequency = Preferences.Default.att_freq.AdjustToBounds(AttitudeFrequencyMin, AttitudeFrequencyMax); private bool _autoDetectIpEnabled = Preferences.Default.ip_detection_enabled; private bool _autoConnectEnabled = Preferences.Default.auto_connect_enabled; private bool _dataAttitudeEnabled = Preferences.Default.att_enabled; private bool _dataPositionEnabled = Preferences.Default.pos_enabled; private bool _dataTrafficEnabled = Preferences.Default.tfk_enabled; private bool _errorOccurred; private IntPtr _hwnd = IntPtr.Zero; private IPAddress? _ipAddress; private uint _ipHintMinutesLeft = Preferences.Default.ip_hint_time; public MainViewModel(DataSender dataSender, SimConnectAdapter simConnect, IpDetectionService ipDetectionService) { _dataSender = dataSender; _simConnect = simConnect; _simConnect.StateChanged += SimConnectStateChanged; _simConnect.PositionReceived += SimConnectPositionReceived; _simConnect.AttitudeReceived += SimConnectAttitudeReceived; _simConnect.TrafficReceived += SimConnectTrafficReceived; _ipDetectionService = ipDetectionService; _ipDetectionService.NewIpDetected += IpDetectionService_NewIpDetected; OpenSettingsCommand = new ActionCommand(OpenSettings); DismissSettingsPaneCommand = new ActionCommand(DismissSettingsPane); GotoNewReleaseCommand = new ActionCommand(GotoReleaseNotesPage); ToggleConnectCommand = new ActionCommand(ToggleConnect, CanConnect); ToggleSettingsPaneCommand = new ActionCommand(ToggleSettingsPane); _ipAddress = IPAddress.TryParse(Preferences.Default.ip_address, out var ip) ? ip : null; _ipHintTimer = new DispatcherTimer(TimeSpan.FromMinutes(1), DispatcherPriority.Normal, IpHintCallback, Dispatcher.CurrentDispatcher); _autoConnectTimer = new DispatcherTimer(TimeSpan.FromSeconds(5), DispatcherPriority.Normal, AutoConnectCallback, Dispatcher.CurrentDispatcher); ManageAutoConnect(); CheckForUpdates(); UpdateVisualState(); } public event PropertyChangedEventHandler? PropertyChanged; [SuppressMessage("ReSharper", "UnusedMember.Local", Justification = "Unknown is not supposed to be used")] private enum FlightSimState { Unknown, Connected, Disconnected, ErrorOccurred, AutoConnecting } public static string WindowTitle => $"fs2ff - {App.InformationalVersion}"; public uint AttitudeFrequency { get => _attitudeFrequency; set { _attitudeFrequency = value.AdjustToBounds(AttitudeFrequencyMin, AttitudeFrequencyMax); _simConnect.SetAttitudeFrequency(_attitudeFrequency); Preferences.Default.att_freq = value; Preferences.Default.Save(); } } public static uint AttitudeFrequencyMax => 10; public static uint AttitudeFrequencyMin => 4; public bool AutoConnectEnabled { get => _autoConnectEnabled; set { if (value != _autoConnectEnabled) { _autoConnectEnabled = value; Preferences.Default.auto_connect_enabled = value; Preferences.Default.Save(); // If auto connect was running and the sim wasn't then there is likely // an error flagged. Clear it whenever AutoConnectEnabled changes state // so in the event auto connect is disabled the window won't show // a meaningless connection error to the user. _errorOccurred = false; ManageAutoConnect(); UpdateVisualState(); } } } public bool AutoConnectLabelVisible { get; private set; } public bool AutoDetectIpEnabled { get => _autoDetectIpEnabled; set { if (value != _autoDetectIpEnabled) { _autoDetectIpEnabled = value; Preferences.Default.ip_detection_enabled = value; Preferences.Default.Save(); } } } public bool ConnectButtonEnabled { get => !_autoConnectEnabled; } public string? ConnectButtonText { get; private set; } public bool ConnectedLabelVisible { get; private set; } public bool DataAttitudeEnabled { get => _dataAttitudeEnabled; set { if (value != _dataAttitudeEnabled) { _dataAttitudeEnabled = value; Preferences.Default.att_enabled = value; Preferences.Default.Save(); } } } public bool DataPositionEnabled { get => _dataPositionEnabled; set { if (value != _dataPositionEnabled) { _dataPositionEnabled = value; Preferences.Default.pos_enabled = value; Preferences.Default.Save(); } } } public bool DataTrafficEnabled { get => _dataTrafficEnabled; set { if (value != _dataTrafficEnabled) { _dataTrafficEnabled = value; Preferences.Default.tfk_enabled = value; Preferences.Default.Save(); } } } public ICommand DismissSettingsPaneCommand { get; } public bool ErrorLabelVisible { get; private set; } public ICommand GotoNewReleaseCommand { get; } public bool IndicatorVisible { get; private set; } public IPAddress? IpAddress { get => _ipAddress; set { if (!Equals(value, _ipAddress)) { _ipAddress = value; Preferences.Default.ip_address = value?.ToString() ?? ""; Preferences.Default.Save(); if (value != null) { ResetIpHintMinutesLeft(); } ResetDataSenderConnection(); } } } public bool IpHintVisible => IpAddress == null && IpHintMinutesLeft == 0; public bool NotLabelVisible { get; private set; } public ICommand OpenSettingsCommand { get; } public bool SettingsPaneVisible { get; set; } public ActionCommand ToggleConnectCommand { get; } public ICommand ToggleSettingsPaneCommand { get; } public bool UpdateMsgVisible => UpdateInfo != null && !SettingsPaneVisible; public IntPtr WindowHandle { get => _hwnd; set { _hwnd = value; ToggleConnectCommand.TriggerCanExecuteChanged(); } } private FlightSimState CurrentFlightSimState => _simConnect.Connected ? FlightSimState.Connected : AutoConnectEnabled ? FlightSimState.AutoConnecting : _errorOccurred ? FlightSimState.ErrorOccurred : FlightSimState.Disconnected; private uint IpHintMinutesLeft { get => _ipHintMinutesLeft; set { if (value != _ipHintMinutesLeft) { _ipHintMinutesLeft = value; Preferences.Default.ip_hint_time = value; Preferences.Default.Save(); } } } private UpdateInformation? UpdateInfo { get; set; } public void Dispose() { _ipDetectionService.NewIpDetected -= IpDetectionService_NewIpDetected; _simConnect.TrafficReceived -= SimConnectTrafficReceived; _simConnect.AttitudeReceived -= SimConnectAttitudeReceived; _simConnect.PositionReceived -= SimConnectPositionReceived; _simConnect.StateChanged -= SimConnectStateChanged; _simConnect.Dispose(); _dataSender.Dispose(); } public void ReceiveFlightSimMessage() => _simConnect.ReceiveMessage(); private void AutoConnectCallback(object? sender, EventArgs e) => Connect(); private bool CanConnect() => WindowHandle != IntPtr.Zero; private void CheckForUpdates() { UpdateChecker.Check().ContinueWith(task => UpdateInfo = task.Result, TaskScheduler.FromCurrentSynchronizationContext()); } private void Connect() => _simConnect.Connect(WindowHandle, AttitudeFrequency); private void Disconnect() => _simConnect.Disconnect(); private void DismissSettingsPane() => SettingsPaneVisible = false; private void GotoReleaseNotesPage() { if (UpdateInfo != null) { Process.Start("explorer.exe", UpdateInfo.DownloadLink.ToString()); } } private void IpDetectionService_NewIpDetected(IPAddress ip) { if (AutoDetectIpEnabled) { IpAddress = ip; } } private void IpHintCallback(object? sender, EventArgs e) { if (IpHintMinutesLeft > 0 && IpAddress == null && _simConnect.Connected) { IpHintMinutesLeft--; } } private void ManageAutoConnect() { if (!AutoConnectEnabled || CurrentFlightSimState == FlightSimState.Connected) { _autoConnectTimer.Stop(); } else { _autoConnectTimer.Start(); } } private void OpenSettings() => SettingsPaneVisible = true; private void ResetDataSenderConnection() { if (CurrentFlightSimState == FlightSimState.Connected) { _dataSender.Connect(IpAddress); } else { _dataSender.Disconnect(); } } private void ResetIpHintMinutesLeft() { Preferences.Default.PropertyValues["ip_hint_time"].SerializedValue = Preferences.Default.Properties["ip_hint_time"].DefaultValue; Preferences.Default.PropertyValues["ip_hint_time"].Deserialized = false; IpHintMinutesLeft = Preferences.Default.ip_hint_time; } private async Task SimConnectAttitudeReceived(Attitude att) { if (DataAttitudeEnabled) { await _dataSender.Send(att).ConfigureAwait(false); } } private async Task SimConnectPositionReceived(Position pos) { if (DataPositionEnabled && (pos.Latitude != 0d || pos.Longitude != 0d)) { await _dataSender.Send(pos).ConfigureAwait(false); } } private void SimConnectStateChanged(bool failure) { _errorOccurred = failure; ManageAutoConnect(); ResetDataSenderConnection(); UpdateVisualState(); } private async Task SimConnectTrafficReceived(Traffic tfk, uint id) { // Ignore traffic with id=1, that's our own aircraft if (DataTrafficEnabled && id != 1) { await _dataSender.Send(tfk, id).ConfigureAwait(false); } } private void ToggleConnect() { if (_simConnect.Connected) Disconnect(); else Connect(); } private void ToggleSettingsPane() => SettingsPaneVisible = !SettingsPaneVisible; private void UpdateVisualState() { (IndicatorVisible, AutoConnectLabelVisible, NotLabelVisible, ErrorLabelVisible, ConnectedLabelVisible, ConnectButtonText) = CurrentFlightSimState switch { FlightSimState.AutoConnecting => (false, true, false, false, false, "Connect"), FlightSimState.Connected => (true, false, false, false, true, "Disconnect"), FlightSimState.Disconnected => (false, false, true, false, true, "Connect"), FlightSimState.ErrorOccurred => (false, false, false, true, false, "Connect"), _ => (false, false, true, false, true, "Connect") }; } } } ================================================ FILE: MainWindow.xaml ================================================