├── .tfignore
├── JustFOV
    ├── App.config
    ├── Properties
    │   ├── Settings.settings
    │   ├── Settings.Designer.cs
    │   ├── AssemblyInfo.cs
    │   ├── Resources.Designer.cs
    │   ├── Resources.resx
    │   └── Annotations.cs
    ├── App.xaml
    ├── App.xaml.cs
    ├── Util
    │   └── RelayCommand.cs
    ├── MainWindow.xaml
    ├── Natives.cs
    ├── MainWindow.xaml.cs
    ├── JustFOV.csproj
    └── Model.cs
├── .gitignore
├── JustFOV.sln.DotSettings
├── README.md
├── JustFOV.sln
└── LICENSE


/.tfignore:
--------------------------------------------------------------------------------
1 | \.git


--------------------------------------------------------------------------------
/JustFOV/App.config:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8" ?>
2 | <configuration>
3 |     <startup> 
4 |         <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.2" />
5 |     </startup>
6 | </configuration>


--------------------------------------------------------------------------------
/JustFOV/Properties/Settings.settings:
--------------------------------------------------------------------------------
1 | <?xml version='1.0' encoding='utf-8'?>
2 | <SettingsFile xmlns="uri:settings" CurrentProfile="(Default)">
3 |   <Profiles>
4 |     <Profile Name="(Default)" />
5 |   </Profiles>
6 |   <Settings />
7 | </SettingsFile>


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | Thumbs.db
 2 | *.obj
 3 | *.exe
 4 | *.pdb
 5 | *.user
 6 | *.aps
 7 | *.pch
 8 | *.vspscc
 9 | *_i.c
10 | *_p.c
11 | *.ncb
12 | *.suo
13 | *.sln.docstates
14 | *.tlb
15 | *.tlh
16 | *.bak
17 | *.cache
18 | *.ilk
19 | *.log
20 | [Bb]in
21 | [Dd]ebug*/
22 | *.lib
23 | *.sbr
24 | obj/
25 | [Rr]elease*/
26 | _ReSharper*/
27 | [Tt]est[Rr]esult*
28 | *.vssscc
29 | $tf*/
30 | JustFOV/JustFOV.pfx
31 | 


--------------------------------------------------------------------------------
/JustFOV/App.xaml:
--------------------------------------------------------------------------------
 1 | <Application x:Class="JustFOV.App"
 2 |              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 3 |              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 4 |              xmlns:local="clr-namespace:JustFOV"
 5 |              StartupUri="MainWindow.xaml">
 6 |     <Application.Resources>
 7 |          
 8 |     </Application.Resources>
 9 | </Application>
10 | 


--------------------------------------------------------------------------------
/JustFOV/App.xaml.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Configuration;
 4 | using System.Data;
 5 | using System.Linq;
 6 | using System.Threading.Tasks;
 7 | using System.Windows;
 8 | 
 9 | namespace JustFOV
10 | {
11 |     /// <summary>
12 |     /// Interaction logic for App.xaml
13 |     /// </summary>
14 |     public partial class App : Application
15 |     {
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/JustFOV.sln.DotSettings:
--------------------------------------------------------------------------------
1 | <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
2 | 	<s:Boolean x:Key="/Default/CodeInspection/CodeAnnotations/NamespacesWithAnnotations/=JustFOV_002EAnnotations/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Just Cause 3 FOV Patcher
 2 | Currently supported patch is 29/07/2016 (Version 1.05).
 3 | 
 4 | ![](https://cloud.githubusercontent.com/assets/2995953/12756496/b80a5328-ca1f-11e5-827c-8d224a24c274.png)
 5 | 
 6 | # Download
 7 | The latest version can be downloaded from https://github.com/xforce/justfov/releases
 8 | 
 9 | # Redistributables
10 | If you encounter issues with missing .NET runtime files, download and install http://go.microsoft.com/fwlink/p/?LinkId=397703.
11 | 


--------------------------------------------------------------------------------
/JustFOV.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio 14
 4 | VisualStudioVersion = 14.0.23107.0
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "JustFOV", "JustFOV\JustFOV.csproj", "{99C575E6-2753-4F55-8311-2FCF312BA5D4}"
 7 | EndProject
 8 | Global
 9 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
10 | 		Debug|Any CPU = Debug|Any CPU
11 | 		Release|Any CPU = Release|Any CPU
12 | 	EndGlobalSection
13 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
14 | 		{99C575E6-2753-4F55-8311-2FCF312BA5D4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
15 | 		{99C575E6-2753-4F55-8311-2FCF312BA5D4}.Debug|Any CPU.Build.0 = Debug|Any CPU
16 | 		{99C575E6-2753-4F55-8311-2FCF312BA5D4}.Release|Any CPU.ActiveCfg = Release|Any CPU
17 | 		{99C575E6-2753-4F55-8311-2FCF312BA5D4}.Release|Any CPU.Build.0 = Release|Any CPU
18 | 	EndGlobalSection
19 | 	GlobalSection(SolutionProperties) = preSolution
20 | 		HideSolutionNode = FALSE
21 | 	EndGlobalSection
22 | EndGlobal
23 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015 Cam
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 
23 | 


--------------------------------------------------------------------------------
/JustFOV/Properties/Settings.Designer.cs:
--------------------------------------------------------------------------------
 1 | //------------------------------------------------------------------------------
 2 | // <auto-generated>
 3 | //     This code was generated by a tool.
 4 | //     Runtime Version:4.0.30319.42000
 5 | //
 6 | //     Changes to this file may cause incorrect behavior and will be lost if
 7 | //     the code is regenerated.
 8 | // </auto-generated>
 9 | //------------------------------------------------------------------------------
10 | 
11 | namespace JustFOV.Properties
12 | {
13 | 
14 | 
15 |     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
16 |     [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.0.0.0")]
17 |     internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase
18 |     {
19 | 
20 |         private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
21 | 
22 |         public static Settings Default
23 |         {
24 |             get
25 |             {
26 |                 return defaultInstance;
27 |             }
28 |         }
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/JustFOV/Util/RelayCommand.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Diagnostics;
 3 | using System.Windows.Input;
 4 | 
 5 | namespace JustFOV.Util
 6 | {
 7 |     public class RelayCommand : ICommand
 8 |     {
 9 |         #region Fields
10 | 
11 |         readonly Action<object> _execute;
12 |         readonly Predicate<object> _canExecute;
13 | 
14 |         #endregion // Fields
15 | 
16 |         #region Constructors
17 | 
18 |         public RelayCommand(Action<object> execute)
19 |         : this(execute, null)
20 |         {
21 |         }
22 | 
23 |         public RelayCommand(Action<object> execute, Predicate<object> canExecute)
24 |         {
25 |             if (execute == null)
26 |                 throw new ArgumentNullException("execute");
27 | 
28 |             _execute = execute;
29 |             _canExecute = canExecute;
30 |         }
31 |         #endregion // Constructors
32 | 
33 |         #region ICommand Members
34 | 
35 |         [DebuggerStepThrough]
36 |         public bool CanExecute(object parameter)
37 |         {
38 |             return _canExecute == null ? true : _canExecute(parameter);
39 |         }
40 | 
41 |         public event EventHandler CanExecuteChanged
42 |         {
43 |             add { CommandManager.RequerySuggested += value; }
44 |             remove { CommandManager.RequerySuggested -= value; }
45 |         }
46 | 
47 |         public void Execute(object parameter)
48 |         {
49 |             _execute(parameter);
50 |         }
51 | 
52 |         #endregion // ICommand Members
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/JustFOV/MainWindow.xaml:
--------------------------------------------------------------------------------
 1 | <Window x:Class="JustFOV.MainWindow"
 2 |         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 3 |         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 4 |         xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
 5 |         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
 6 |         xmlns:local="clr-namespace:JustFOV"
 7 |         mc:Ignorable="d"
 8 |         Title="Just FOV" Height="160" Width="280" ResizeMode="CanMinimize">
 9 |     <Grid>
10 |         <Grid.RowDefinitions>
11 |             <RowDefinition Height="30"></RowDefinition>
12 |             <RowDefinition Height="30"></RowDefinition>
13 |         </Grid.RowDefinitions>
14 |         <Grid.ColumnDefinitions>
15 |             <ColumnDefinition Width="200"></ColumnDefinition>
16 |             <ColumnDefinition Width="*"></ColumnDefinition>
17 |         </Grid.ColumnDefinitions>
18 | 
19 |         <Slider Grid.Row="0" Grid.Column="0" Margin="5" Value="{Binding Fov, Mode=TwoWay}" x:Name="FOVSlider" />
20 |         <TextBlock Grid.Row="0" Grid.Column="1" Margin="5" Text="{Binding Fov, StringFormat=FOV:{0}}" />
21 | 
22 |         <TextBox Grid.Row="1" Grid.Column="0" Margin="5" Text="{Binding Fov, Mode=TwoWay}" x:Name="FOVText"></TextBox>
23 |         <Button Grid.Row="1" Grid.Column="1" Margin="5" Content="Set FOV" x:Name="SetFov"></Button>
24 | 
25 |         <Button Grid.Row="1" Grid.Column="1" Margin="5,26.667,4.667,-16.333" Command="{Binding RestoreDefaultFOV}" Content="Default" />
26 |         <Label x:Name="label" Content="NumPad / -  Incr. FOV&#xD;&#xA;NumPad * - Decr. FOV&#xD;&#xA;NumPad Period - Toggle Override" Margin="5,31,5,-59" Grid.Row="1" FontSize="10" VerticalContentAlignment="Stretch"/>
27 |     </Grid>
28 | </Window>
29 | 


--------------------------------------------------------------------------------
/JustFOV/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Resources;
 3 | using System.Runtime.CompilerServices;
 4 | using System.Runtime.InteropServices;
 5 | using System.Windows;
 6 | 
 7 | // General Information about an assembly is controlled through the following 
 8 | // set of attributes. Change these attribute values to modify the information
 9 | // associated with an assembly.
10 | [assembly: AssemblyTitle("Just Cause 3 FOV Patcher")]
11 | [assembly: AssemblyDescription("")]
12 | [assembly: AssemblyConfiguration("")]
13 | [assembly: AssemblyCompany("")]
14 | [assembly: AssemblyProduct("Just Cause 3 FOV Patcher")]
15 | [assembly: AssemblyCopyright("Copyright © Trix 2015")]
16 | [assembly: AssemblyTrademark("")]
17 | [assembly: AssemblyCulture("")]
18 | 
19 | // Setting ComVisible to false makes the types in this assembly not visible 
20 | // to COM components.  If you need to access a type in this assembly from 
21 | // COM, set the ComVisible attribute to true on that type.
22 | [assembly: ComVisible(false)]
23 | 
24 | //In order to begin building localizable applications, set 
25 | //<UICulture>CultureYouAreCodingWith</UICulture> in your .csproj file
26 | //inside a <PropertyGroup>.  For example, if you are using US english
27 | //in your source files, set the <UICulture> to en-US.  Then uncomment
28 | //the NeutralResourceLanguage attribute below.  Update the "en-US" in
29 | //the line below to match the UICulture setting in the project file.
30 | 
31 | //[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)]
32 | 
33 | 
34 | [assembly: ThemeInfo(
35 |     ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located
36 |                                      //(used if a resource is not found in the page, 
37 |                                      // or application resource dictionaries)
38 |     ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located
39 |                                               //(used if a resource is not found in the page, 
40 |                                               // app, or any theme specific resource dictionaries)
41 | )]
42 | 
43 | 
44 | // Version information for an assembly consists of the following four values:
45 | //
46 | //      Major Version
47 | //      Minor Version 
48 | //      Build Number
49 | //      Revision
50 | //
51 | // You can specify all the values or you can default the Build and Revision Numbers 
52 | // by using the '*' as shown below:
53 | // [assembly: AssemblyVersion("1.0.*")]
54 | [assembly: AssemblyVersion("1.0.0.0")]
55 | [assembly: AssemblyFileVersion("1.0.0.0")]
56 | 


--------------------------------------------------------------------------------
/JustFOV/Natives.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Runtime.InteropServices;
 3 | 
 4 | namespace JustFOV
 5 | {
 6 |     public class Natives
 7 |     {
 8 |         #region ProcessAccessFlags
 9 | 
10 |         public enum ProcessAccessFlags : uint
11 |         {
12 |             All = 0x001F0FFF,
13 |             Terminate = 0x00000001,
14 |             CreateThread = 0x00000002,
15 |             VMOperation = 0x00000008,
16 |             VMRead = 0x00000010,
17 |             VMWrite = 0x00000020,
18 |             DupHandle = 0x00000040,
19 |             SetInformation = 0x00000200,
20 |             QueryInformation = 0x00000400,
21 |             Synchronize = 0x00100000
22 |         }
23 | 
24 |         #endregion
25 | 
26 |         #region Imports
27 | 
28 |         [DllImport("kernel32.dll")]
29 |         public static extern IntPtr OpenProcess(uint dwDesiredAccess,
30 |             [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, int dwProcessId);
31 | 
32 |         [DllImport("kernel32.dll", SetLastError = true)]
33 |         public static extern bool ReadProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, byte[] lpBuffer,
34 |             int dwSize, out int lpNumberOfBytesRead);
35 | 
36 |         [DllImport("kernel32.dll", SetLastError = true)]
37 |         public static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, byte[] lpBuffer,
38 |             uint nSize, out int lpNumberOfBytesWritten);
39 | 
40 |         #endregion
41 | 
42 |         #region Helpers
43 | 
44 |         public static byte[] ReadBytes(IntPtr handle, IntPtr address, uint numBytes)
45 |         {
46 |             var buf = new byte[numBytes];
47 |             var numBytesRead = 0;
48 |             ReadProcessMemory(handle, address, buf, buf.Length, out numBytesRead);
49 | 
50 |             return buf;
51 |         }
52 | 
53 |         public static void WriteBytes(IntPtr handle, IntPtr address, byte[] bytes)
54 |         {
55 |             var numBytesWritten = 0;
56 |             WriteProcessMemory(handle, address, bytes, (uint) bytes.Length, out numBytesWritten);
57 |         }
58 | 
59 |         public static IntPtr ReadIntPtr(IntPtr handle, IntPtr address)
60 |         {
61 |             var buf = ReadBytes(handle, address, (uint) IntPtr.Size);
62 | 
63 |             return new IntPtr(BitConverter.ToInt64(buf, 0));
64 |         }
65 | 
66 |         public static void WriteFloat(IntPtr handle, IntPtr address, float f)
67 |         {
68 |             var buf = BitConverter.GetBytes(f);
69 | 
70 |             WriteBytes(handle, address, buf);
71 |         }
72 | 
73 |         public static float ReadFloat(IntPtr handle, IntPtr address)
74 |         {
75 |             var buf = ReadBytes(handle, address, 4);
76 | 
77 |             return BitConverter.ToSingle(buf, 0);
78 |         }
79 | 
80 |         #endregion
81 |     }
82 | }


--------------------------------------------------------------------------------
/JustFOV/Properties/Resources.Designer.cs:
--------------------------------------------------------------------------------
 1 | //------------------------------------------------------------------------------
 2 | // <auto-generated>
 3 | //     This code was generated by a tool.
 4 | //     Runtime Version:4.0.30319.42000
 5 | //
 6 | //     Changes to this file may cause incorrect behavior and will be lost if
 7 | //     the code is regenerated.
 8 | // </auto-generated>
 9 | //------------------------------------------------------------------------------
10 | 
11 | namespace JustFOV.Properties
12 | {
13 | 
14 | 
15 |     /// <summary>
16 |     ///   A strongly-typed resource class, for looking up localized strings, etc.
17 |     /// </summary>
18 |     // This class was auto-generated by the StronglyTypedResourceBuilder
19 |     // class via a tool like ResGen or Visual Studio.
20 |     // To add or remove a member, edit your .ResX file then rerun ResGen
21 |     // with the /str option, or rebuild your VS project.
22 |     [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
23 |     [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
24 |     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
25 |     internal class Resources
26 |     {
27 | 
28 |         private static global::System.Resources.ResourceManager resourceMan;
29 | 
30 |         private static global::System.Globalization.CultureInfo resourceCulture;
31 | 
32 |         [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
33 |         internal Resources()
34 |         {
35 |         }
36 | 
37 |         /// <summary>
38 |         ///   Returns the cached ResourceManager instance used by this class.
39 |         /// </summary>
40 |         [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
41 |         internal static global::System.Resources.ResourceManager ResourceManager
42 |         {
43 |             get
44 |             {
45 |                 if ((resourceMan == null))
46 |                 {
47 |                     global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("JustFOV.Properties.Resources", typeof(Resources).Assembly);
48 |                     resourceMan = temp;
49 |                 }
50 |                 return resourceMan;
51 |             }
52 |         }
53 | 
54 |         /// <summary>
55 |         ///   Overrides the current thread's CurrentUICulture property for all
56 |         ///   resource lookups using this strongly typed resource class.
57 |         /// </summary>
58 |         [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
59 |         internal static global::System.Globalization.CultureInfo Culture
60 |         {
61 |             get
62 |             {
63 |                 return resourceCulture;
64 |             }
65 |             set
66 |             {
67 |                 resourceCulture = value;
68 |             }
69 |         }
70 |     }
71 | }
72 | 


--------------------------------------------------------------------------------
/JustFOV/MainWindow.xaml.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Diagnostics;
  3 | using System.Runtime.InteropServices;
  4 | using System.Windows;
  5 | using System.Windows.Input;
  6 | 
  7 | namespace JustFOV
  8 | {
  9 |     /// <summary>
 10 |     ///     Interaction logic for MainWindow.xaml
 11 |     /// </summary>
 12 |     public partial class MainWindow : Window
 13 |     {
 14 |         private const int minFOV = 1;
 15 |         private const int maxFOV = 90;
 16 | 
 17 |         private static MainWindow Instance;
 18 |         private Model model;
 19 | 
 20 |         public MainWindow()
 21 |         {
 22 |             InitializeComponent();
 23 | 
 24 |             DataContext = new Model();
 25 |             model = DataContext as Model;
 26 | 
 27 |             SetFov.Click += SetFov_Click;
 28 | 
 29 |             FOVSlider.Minimum = minFOV;
 30 |             FOVSlider.Maximum = maxFOV;
 31 | 
 32 |             Instance = this;
 33 |             _hookID = SetHook(_onHookEvent);
 34 |         }
 35 | 
 36 |         ~MainWindow()
 37 |         {
 38 |             UnhookWindowsHookEx(_hookID);
 39 |         }
 40 | 
 41 |         private void SetFov_Click(object sender, RoutedEventArgs e)
 42 |         {
 43 |             float FOVValue;
 44 |             if (float.TryParse(FOVText.Text, out FOVValue))
 45 |             {
 46 |                 //var model = DataContext as Model;
 47 |                 if (FOVValue < minFOV || FOVValue > 90)
 48 |                 {
 49 |                     MessageBox.Show("FOV should be between 1 and 90", "Error", MessageBoxButton.OK,
 50 |                         MessageBoxImage.Error);
 51 |                 }
 52 |                 else
 53 |                 {
 54 |                     if (model != null) model.Fov = FOVValue;
 55 |                 }
 56 |             }
 57 |             else
 58 |             {
 59 |                 MessageBox.Show("Invalid FOV supplied", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
 60 |             }
 61 |         }
 62 | 
 63 | 
 64 | 
 65 | 
 66 | 
 67 | 
 68 |        
 69 | 
 70 | 
 71 |         [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
 72 |         private static extern IntPtr SetWindowsHookEx(int idHook, LowLevelKeyboardProc lpfn, IntPtr hMod, uint dwThreadId);
 73 | 
 74 | 
 75 |         [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
 76 |         [return: MarshalAs(UnmanagedType.Bool)]
 77 |         private static extern bool UnhookWindowsHookEx(IntPtr hhk);
 78 | 
 79 | 
 80 |         [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
 81 |         private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam);
 82 | 
 83 | 
 84 |         [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
 85 |         private static extern IntPtr GetModuleHandle(string lpModuleName);
 86 | 
 87 |         private delegate IntPtr LowLevelKeyboardProc(int nCode, IntPtr wParam, IntPtr lParam);
 88 |         private static LowLevelKeyboardProc _onHookEvent = HookCallback;
 89 | 
 90 |         private static IntPtr _hookID = IntPtr.Zero;
 91 | 
 92 | 
 93 |         private const int WH_KEYBOARD_LL = 13;
 94 | 
 95 |         enum WM
 96 |         {
 97 |             KEYDOWN = 0x0100,
 98 |             KEYUP = 0x101
 99 | 
100 |         }
101 | 
102 | 
103 |         private static IntPtr SetHook(LowLevelKeyboardProc proc)
104 |         {
105 |             using (Process curProcess = Process.GetCurrentProcess())
106 |             using (ProcessModule curModule = curProcess.MainModule)
107 |             {
108 | 
109 |                 return SetWindowsHookEx(WH_KEYBOARD_LL, proc, GetModuleHandle(curModule.ModuleName), 0);
110 |             }
111 |         }
112 | 
113 | 
114 |         private static IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
115 |         {
116 |             if (nCode >= 0 && wParam == (IntPtr)WM.KEYUP)
117 |             {
118 |                 int vkCode = Marshal.ReadInt32(lParam);
119 | 
120 |                 if (Instance != null)
121 |                 {
122 |                     Key k = KeyInterop.KeyFromVirtualKey(vkCode);
123 | 
124 |                     Instance.OnKeyHookEvent(k);
125 |                 }
126 |             }
127 | 
128 |             return CallNextHookEx(_hookID, nCode, wParam, lParam);
129 |         }
130 | 
131 |         protected void OnKeyHookEvent(Key k)
132 |         {
133 |             switch (k)
134 |             {
135 |                 default:
136 |                     return;
137 |                 case Key.Decimal:
138 |                     if (model != null)
139 |                     {
140 |                         model.PatchSetFov(!model.FovHackEnabled);
141 |                         model.RecallFov();
142 |                     }
143 |                     break;
144 |                 case Key.Divide:
145 |                     if (model != null)
146 |                     {
147 |                         model.Fov = Math.Min(maxFOV, model.Fov + 5f);
148 |                     }
149 |                     break;
150 |                 case Key.Multiply:
151 |                     if (model != null)
152 |                     {
153 |                         model.Fov = Math.Max(minFOV, model.Fov - 5f);
154 |                     }
155 |                     break;
156 |             }
157 |             FOVText.Text = model.Fov.ToString("0");
158 |         }
159 |     }
160 | }


--------------------------------------------------------------------------------
/JustFOV/Properties/Resources.resx:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <root>
  3 |   <!-- 
  4 |     Microsoft ResX Schema 
  5 |     
  6 |     Version 2.0
  7 |     
  8 |     The primary goals of this format is to allow a simple XML format 
  9 |     that is mostly human readable. The generation and parsing of the 
 10 |     various data types are done through the TypeConverter classes 
 11 |     associated with the data types.
 12 |     
 13 |     Example:
 14 |     
 15 |     ... ado.net/XML headers & schema ...
 16 |     <resheader name="resmimetype">text/microsoft-resx</resheader>
 17 |     <resheader name="version">2.0</resheader>
 18 |     <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
 19 |     <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
 20 |     <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
 21 |     <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
 22 |     <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
 23 |         <value>[base64 mime encoded serialized .NET Framework object]</value>
 24 |     </data>
 25 |     <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
 26 |         <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
 27 |         <comment>This is a comment</comment>
 28 |     </data>
 29 |                 
 30 |     There are any number of "resheader" rows that contain simple 
 31 |     name/value pairs.
 32 |     
 33 |     Each data row contains a name, and value. The row also contains a 
 34 |     type or mimetype. Type corresponds to a .NET class that support 
 35 |     text/value conversion through the TypeConverter architecture. 
 36 |     Classes that don't support this are serialized and stored with the 
 37 |     mimetype set.
 38 |     
 39 |     The mimetype is used for serialized objects, and tells the 
 40 |     ResXResourceReader how to depersist the object. This is currently not 
 41 |     extensible. For a given mimetype the value must be set accordingly:
 42 |     
 43 |     Note - application/x-microsoft.net.object.binary.base64 is the format 
 44 |     that the ResXResourceWriter will generate, however the reader can 
 45 |     read any of the formats listed below.
 46 |     
 47 |     mimetype: application/x-microsoft.net.object.binary.base64
 48 |     value   : The object must be serialized with 
 49 |             : System.Serialization.Formatters.Binary.BinaryFormatter
 50 |             : and then encoded with base64 encoding.
 51 |     
 52 |     mimetype: application/x-microsoft.net.object.soap.base64
 53 |     value   : The object must be serialized with 
 54 |             : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
 55 |             : and then encoded with base64 encoding.
 56 | 
 57 |     mimetype: application/x-microsoft.net.object.bytearray.base64
 58 |     value   : The object must be serialized into a byte array 
 59 |             : using a System.ComponentModel.TypeConverter
 60 |             : and then encoded with base64 encoding.
 61 |     -->
 62 |   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
 63 |     <xsd:element name="root" msdata:IsDataSet="true">
 64 |       <xsd:complexType>
 65 |         <xsd:choice maxOccurs="unbounded">
 66 |           <xsd:element name="metadata">
 67 |             <xsd:complexType>
 68 |               <xsd:sequence>
 69 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" />
 70 |               </xsd:sequence>
 71 |               <xsd:attribute name="name" type="xsd:string" />
 72 |               <xsd:attribute name="type" type="xsd:string" />
 73 |               <xsd:attribute name="mimetype" type="xsd:string" />
 74 |             </xsd:complexType>
 75 |           </xsd:element>
 76 |           <xsd:element name="assembly">
 77 |             <xsd:complexType>
 78 |               <xsd:attribute name="alias" type="xsd:string" />
 79 |               <xsd:attribute name="name" type="xsd:string" />
 80 |             </xsd:complexType>
 81 |           </xsd:element>
 82 |           <xsd:element name="data">
 83 |             <xsd:complexType>
 84 |               <xsd:sequence>
 85 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
 86 |                 <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
 87 |               </xsd:sequence>
 88 |               <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
 89 |               <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
 90 |               <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
 91 |             </xsd:complexType>
 92 |           </xsd:element>
 93 |           <xsd:element name="resheader">
 94 |             <xsd:complexType>
 95 |               <xsd:sequence>
 96 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
 97 |               </xsd:sequence>
 98 |               <xsd:attribute name="name" type="xsd:string" use="required" />
 99 |             </xsd:complexType>
100 |           </xsd:element>
101 |         </xsd:choice>
102 |       </xsd:complexType>
103 |     </xsd:element>
104 |   </xsd:schema>
105 |   <resheader name="resmimetype">
106 |     <value>text/microsoft-resx</value>
107 |   </resheader>
108 |   <resheader name="version">
109 |     <value>2.0</value>
110 |   </resheader>
111 |   <resheader name="reader">
112 |     <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
113 |   </resheader>
114 |   <resheader name="writer">
115 |     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
116 |   </resheader>
117 | </root>


--------------------------------------------------------------------------------
/JustFOV/JustFOV.csproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
  4 |   <PropertyGroup>
  5 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
  6 |     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
  7 |     <ProjectGuid>{99C575E6-2753-4F55-8311-2FCF312BA5D4}</ProjectGuid>
  8 |     <OutputType>WinExe</OutputType>
  9 |     <AppDesignerFolder>Properties</AppDesignerFolder>
 10 |     <RootNamespace>JustFOV</RootNamespace>
 11 |     <AssemblyName>JustFOV</AssemblyName>
 12 |     <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
 13 |     <FileAlignment>512</FileAlignment>
 14 |     <ProjectTypeGuids>{60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
 15 |     <WarningLevel>4</WarningLevel>
 16 |     <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
 17 |     <PublishUrl>publish\</PublishUrl>
 18 |     <Install>true</Install>
 19 |     <InstallFrom>Disk</InstallFrom>
 20 |     <UpdateEnabled>false</UpdateEnabled>
 21 |     <UpdateMode>Foreground</UpdateMode>
 22 |     <UpdateInterval>7</UpdateInterval>
 23 |     <UpdateIntervalUnits>Days</UpdateIntervalUnits>
 24 |     <UpdatePeriodically>false</UpdatePeriodically>
 25 |     <UpdateRequired>false</UpdateRequired>
 26 |     <MapFileExtensions>true</MapFileExtensions>
 27 |     <ApplicationRevision>0</ApplicationRevision>
 28 |     <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
 29 |     <IsWebBootstrapper>false</IsWebBootstrapper>
 30 |     <UseApplicationTrust>false</UseApplicationTrust>
 31 |     <BootstrapperEnabled>true</BootstrapperEnabled>
 32 |   </PropertyGroup>
 33 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
 34 |     <PlatformTarget>x64</PlatformTarget>
 35 |     <DebugSymbols>true</DebugSymbols>
 36 |     <DebugType>full</DebugType>
 37 |     <Optimize>false</Optimize>
 38 |     <OutputPath>bin\Debug\</OutputPath>
 39 |     <DefineConstants>DEBUG;TRACE</DefineConstants>
 40 |     <ErrorReport>prompt</ErrorReport>
 41 |     <WarningLevel>4</WarningLevel>
 42 |   </PropertyGroup>
 43 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
 44 |     <PlatformTarget>x64</PlatformTarget>
 45 |     <DebugType>pdbonly</DebugType>
 46 |     <Optimize>true</Optimize>
 47 |     <OutputPath>bin\Release\</OutputPath>
 48 |     <DefineConstants>TRACE</DefineConstants>
 49 |     <ErrorReport>prompt</ErrorReport>
 50 |     <WarningLevel>4</WarningLevel>
 51 |   </PropertyGroup>
 52 |   <PropertyGroup>
 53 |     <SignAssembly>true</SignAssembly>
 54 |   </PropertyGroup>
 55 |   <PropertyGroup>
 56 |     <AssemblyOriginatorKeyFile>JustFOV.pfx</AssemblyOriginatorKeyFile>
 57 |   </PropertyGroup>
 58 |   <ItemGroup>
 59 |     <Reference Include="System" />
 60 |     <Reference Include="System.Data" />
 61 |     <Reference Include="System.Xml" />
 62 |     <Reference Include="Microsoft.CSharp" />
 63 |     <Reference Include="System.Core" />
 64 |     <Reference Include="System.Xml.Linq" />
 65 |     <Reference Include="System.Data.DataSetExtensions" />
 66 |     <Reference Include="System.Net.Http" />
 67 |     <Reference Include="System.Xaml">
 68 |       <RequiredTargetFramework>4.0</RequiredTargetFramework>
 69 |     </Reference>
 70 |     <Reference Include="WindowsBase" />
 71 |     <Reference Include="PresentationCore" />
 72 |     <Reference Include="PresentationFramework" />
 73 |   </ItemGroup>
 74 |   <ItemGroup>
 75 |     <ApplicationDefinition Include="App.xaml">
 76 |       <Generator>MSBuild:Compile</Generator>
 77 |       <SubType>Designer</SubType>
 78 |     </ApplicationDefinition>
 79 |     <Compile Include="Util\RelayCommand.cs" />
 80 |     <Page Include="MainWindow.xaml">
 81 |       <Generator>MSBuild:Compile</Generator>
 82 |       <SubType>Designer</SubType>
 83 |     </Page>
 84 |     <Compile Include="App.xaml.cs">
 85 |       <DependentUpon>App.xaml</DependentUpon>
 86 |       <SubType>Code</SubType>
 87 |     </Compile>
 88 |     <Compile Include="MainWindow.xaml.cs">
 89 |       <DependentUpon>MainWindow.xaml</DependentUpon>
 90 |       <SubType>Code</SubType>
 91 |     </Compile>
 92 |   </ItemGroup>
 93 |   <ItemGroup>
 94 |     <Compile Include="Model.cs" />
 95 |     <Compile Include="Natives.cs" />
 96 |     <Compile Include="Properties\Annotations.cs" />
 97 |     <Compile Include="Properties\AssemblyInfo.cs">
 98 |       <SubType>Code</SubType>
 99 |     </Compile>
100 |     <Compile Include="Properties\Resources.Designer.cs">
101 |       <AutoGen>True</AutoGen>
102 |       <DesignTime>True</DesignTime>
103 |       <DependentUpon>Resources.resx</DependentUpon>
104 |     </Compile>
105 |     <Compile Include="Properties\Settings.Designer.cs">
106 |       <AutoGen>True</AutoGen>
107 |       <DependentUpon>Settings.settings</DependentUpon>
108 |       <DesignTimeSharedInput>True</DesignTimeSharedInput>
109 |     </Compile>
110 |     <EmbeddedResource Include="Properties\Resources.resx">
111 |       <Generator>ResXFileCodeGenerator</Generator>
112 |       <LastGenOutput>Resources.Designer.cs</LastGenOutput>
113 |     </EmbeddedResource>
114 |     <None Include="JustFOV.pfx" />
115 |     <None Include="Properties\Settings.settings">
116 |       <Generator>SettingsSingleFileGenerator</Generator>
117 |       <LastGenOutput>Settings.Designer.cs</LastGenOutput>
118 |     </None>
119 |     <AppDesigner Include="Properties\" />
120 |   </ItemGroup>
121 |   <ItemGroup>
122 |     <None Include="App.config" />
123 |   </ItemGroup>
124 |   <ItemGroup>
125 |     <BootstrapperPackage Include=".NETFramework,Version=v4.5.2">
126 |       <Visible>False</Visible>
127 |       <ProductName>Microsoft .NET Framework 4.5.2 %28x86 and x64%29</ProductName>
128 |       <Install>true</Install>
129 |     </BootstrapperPackage>
130 |     <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
131 |       <Visible>False</Visible>
132 |       <ProductName>.NET Framework 3.5 SP1</ProductName>
133 |       <Install>false</Install>
134 |     </BootstrapperPackage>
135 |   </ItemGroup>
136 |   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
137 |   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
138 |        Other similar extension points exist, see Microsoft.Common.targets.
139 |   <Target Name="BeforeBuild">
140 |   </Target>
141 |   <Target Name="AfterBuild">
142 |   </Target>
143 |   -->
144 | </Project>


--------------------------------------------------------------------------------
/JustFOV/Model.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.ComponentModel;
  3 | using System.Diagnostics;
  4 | using System.Runtime.CompilerServices;
  5 | using System.Windows;
  6 | using JustFOV.Annotations;
  7 | using JustFOV.Util;
  8 | using System.Windows.Input;
  9 | 
 10 | namespace JustFOV
 11 | {
 12 |     public class Model : INotifyPropertyChanged
 13 |     {
 14 |         private const float DegToRad = (float) (Math.PI/180.0f);
 15 |         private const float RadToDeg = (float) (180.0f/Math.PI);
 16 |         private readonly IntPtr _handle;
 17 | 
 18 |         private readonly byte[] _originalCallBytes;
 19 | 
 20 |         private ICommand _restoreDefaultFOVCommand;
 21 |         private float _defaultFOV = 34.89f;
 22 | 
 23 |         private bool _fovHackEnabled;
 24 |         private float _fovRecall;
 25 | 
 26 |         public Model()
 27 |         {
 28 |             var processes = Process.GetProcessesByName("JustCause3");
 29 |             if (processes.Length == 0)
 30 |             {
 31 |                 MessageBox.Show("Failed to find JustCause3.exe process", "Error", MessageBoxButton.OK,
 32 |                     MessageBoxImage.Error);
 33 |                 Application.Current.Shutdown(0);
 34 |             }
 35 | 
 36 |             _handle = Natives.OpenProcess(
 37 |                 (uint) Natives.ProcessAccessFlags.VMOperation |
 38 |                 (uint) Natives.ProcessAccessFlags.VMRead |
 39 |                 (uint) Natives.ProcessAccessFlags.VMWrite, false, processes[0].Id);
 40 | 
 41 |             if (_handle == IntPtr.Zero)
 42 |             {
 43 |                 MessageBox.Show("Failed to open a handle to JustCause3.exe process", "Error", MessageBoxButton.OK,
 44 |                     MessageBoxImage.Error);
 45 |                 Application.Current.Shutdown(0);
 46 |             }
 47 | 
 48 |             _originalCallBytes = Natives.ReadBytes(_handle, _setFovCall, 5);
 49 | 
 50 |             PatchSetFov(true);
 51 |         }
 52 | 
 53 |         #region Properties
 54 | 
 55 |         public float Fov
 56 |         {
 57 |             get { return GetFov()*RadToDeg; }
 58 |             set
 59 |             {
 60 |                 PatchFov(value*DegToRad);
 61 | 
 62 |                 OnPropertyChanged();
 63 |             }
 64 |         }
 65 | 
 66 |         public ICommand RestoreDefaultFOV
 67 |         {
 68 |             get
 69 |             {
 70 |                 return _restoreDefaultFOVCommand ??
 71 |                     (_restoreDefaultFOVCommand = new RelayCommand(p => Fov = _defaultFOV));
 72 |             }
 73 |         }
 74 | 
 75 |         public bool FovHackEnabled
 76 |         {
 77 |             get
 78 |             {
 79 |                 return _fovHackEnabled;
 80 |             }
 81 |         }
 82 | 
 83 |         #endregion
 84 | 
 85 |         ~Model()
 86 |         {
 87 |             PatchSetFov(false);
 88 |         }
 89 | 
 90 |         public void PatchSetFov(bool overrideEnable)
 91 |         {
 92 |             _fovHackEnabled = overrideEnable;
 93 | 
 94 |             Natives.WriteBytes(_handle, _setFovCall,
 95 |                 overrideEnable ? new byte[] {0x90, 0x90, 0x90, 0x90, 0x90} : _originalCallBytes);
 96 |         }
 97 | 
 98 |         public void RecallFov()
 99 |         {
100 |             PatchFov(_fovRecall);
101 |         }
102 | 
103 |         private void PatchFov(float newFov)
104 |         {
105 |             _fovRecall = newFov;
106 | 
107 |             var cameraManager = Natives.ReadIntPtr(_handle, _cameraManagerPtr);
108 |             var currentCamera = Natives.ReadIntPtr(_handle, cameraManager + CurrentCameraOffset);
109 | 
110 |             // Update the flags to indicate an FOV change has occurred
111 |             var flags = Natives.ReadBytes(_handle, currentCamera + CameraFlagsOffset, 1);
112 |             flags[0] |= 0x10;
113 |             Natives.WriteBytes(_handle, currentCamera + CameraFlagsOffset, flags);
114 | 
115 |             // Update the actual FOV values
116 |             Natives.WriteFloat(_handle, currentCamera + FovOffset1, newFov);
117 |             Natives.WriteFloat(_handle, currentCamera + FovOffset2, newFov);
118 |         }
119 | 
120 |         private float GetFov()
121 |         {
122 |             var cameraManager = Natives.ReadIntPtr(_handle, _cameraManagerPtr);
123 |             var currentCamera = Natives.ReadIntPtr(_handle, cameraManager + CurrentCameraOffset);
124 | 
125 |             return Natives.ReadFloat(_handle, currentCamera + FovOffset2);
126 |         }
127 | 
128 |         #region Offsets
129 | 
130 |         // Patch 1.021
131 |         //private readonly IntPtr _cameraManagerPtr = new IntPtr(0x142e72a58);
132 |         //private readonly IntPtr _setFovCall = new IntPtr(0x143a546cf);
133 | 
134 |         //private const int CurrentCameraOffset = 0x5c0;
135 |         //private const int CameraFlagsOffset = 0x55e;
136 |         //private const int FovOffset1 = 0x580;
137 |         //private const int FovOffset2 = 0x584;
138 | 
139 |         // Patch 20/01/2016
140 |         //private readonly IntPtr _cameraManagerPtr = new IntPtr(0x142e72a58);
141 |         //private readonly IntPtr _setFovCall = new IntPtr(0x143229d70);
142 | 
143 |         //private const int CurrentCameraOffset = 0x5c0;
144 |         //private const int CameraFlagsOffset = 0x55e;
145 |         //private const int FovOffset1 = 0x580;
146 |         //private const int FovOffset2 = 0x584;
147 | 
148 |         // Patch 07/03/2016
149 |         //private readonly IntPtr _cameraManagerPtr = new IntPtr(0x142F0CB58);
150 |         //private readonly IntPtr _setFovCall = new IntPtr(0x143B3BC2D);
151 | 
152 |         //private const int CurrentCameraOffset = 0x5c0;
153 |         //private const int CameraFlagsOffset = 0x55e;
154 |         //private const int FovOffset1 = 0x580;
155 |         //private const int FovOffset2 = 0x584;
156 | 
157 |         // Patch version 1.04 (03/06/2016)
158 |         // NOTE(xforce): If I were to inject something in the process I could make this work independent of version
159 |         // But I don't think that was the intention of this program
160 |         // Or I write some memory search using ReadProcessMemory but that is slow
161 |         // So on the next update use this to find the address to CameraManager easily
162 |         // Or use a dump in IDA look for the ctor of CCameraManager
163 |         // 48 8B 05 ? ? ? ? F3 0F 10 05 ? ? ? ? 4D 89 C1 48 8B 90 ? ? ? ? 4C 8D 41 0C 31 C0
164 |         // This is a IDA compatible pattern
165 | 
166 |         // This is the pattern for the SetFOV Call
167 |         // E8 ? ? ? ? 0F 28 BC 24 ? ? ? ? 0F 28 B4 24 ? ? ? ? 48 8B 9C 24 ? ? ? ? 48 81 C4 ? ? ? ?
168 |         // I however thing it's not required to patch it as this is only called
169 |         // when the camera manager gets created
170 |         // Or maybe I just have the wrong call
171 |         // But I was not able to acquire the versions used previously, so ye
172 | 
173 |         //private readonly IntPtr _cameraManagerPtr = new IntPtr(0x142EBEBD0);
174 |         //private readonly IntPtr _setFovCall = new IntPtr(0x143ADAD71);
175 | 
176 |         //private const int CurrentCameraOffset = 0x5c0;
177 |         //private const int CameraFlagsOffset = 0x55e;
178 |         //private const int FovOffset1 = 0x580;
179 |         //private const int FovOffset2 = 0x584;
180 | 
181 |         // Patch version 1.05 (29/07/2016)
182 |         private readonly IntPtr _cameraManagerPtr = new IntPtr(0x142ED0E20);
183 |         private readonly IntPtr _setFovCall = new IntPtr(0x143AEFF41);
184 | 
185 |         private const int CurrentCameraOffset = 0x5c0;
186 |         private const int CameraFlagsOffset = 0x55e;
187 |         private const int FovOffset1 = 0x580;
188 |         private const int FovOffset2 = 0x584;
189 | 
190 |         #endregion
191 | 
192 |         #region INotifyPropertyChanged
193 | 
194 |         public event PropertyChangedEventHandler PropertyChanged;
195 | 
196 |         [NotifyPropertyChangedInvocator]
197 |         protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
198 |         {
199 |             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
200 |         }
201 | 
202 |         #endregion
203 |     }
204 | }


--------------------------------------------------------------------------------
/JustFOV/Properties/Annotations.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | 
  3 | #pragma warning disable 1591
  4 | // ReSharper disable UnusedMember.Global
  5 | // ReSharper disable MemberCanBePrivate.Global
  6 | // ReSharper disable UnusedAutoPropertyAccessor.Global
  7 | // ReSharper disable IntroduceOptionalParameters.Global
  8 | // ReSharper disable MemberCanBeProtected.Global
  9 | // ReSharper disable InconsistentNaming
 10 | 
 11 | namespace JustFOV.Annotations
 12 | {
 13 |   /// <summary>
 14 |   /// Indicates that the value of the marked element could be <c>null</c> sometimes,
 15 |   /// so the check for <c>null</c> is necessary before its usage.
 16 |   /// </summary>
 17 |   /// <example><code>
 18 |   /// [CanBeNull] object Test() => null;
 19 |   /// 
 20 |   /// void UseTest() {
 21 |   ///   var p = Test();
 22 |   ///   var s = p.ToString(); // Warning: Possible 'System.NullReferenceException'
 23 |   /// }
 24 |   /// </code></example>
 25 |   [AttributeUsage(
 26 |     AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
 27 |     AttributeTargets.Delegate | AttributeTargets.Field | AttributeTargets.Event)]
 28 |   public sealed class CanBeNullAttribute : Attribute { }
 29 | 
 30 |   /// <summary>
 31 |   /// Indicates that the value of the marked element could never be <c>null</c>.
 32 |   /// </summary>
 33 |   /// <example><code>
 34 |   /// [NotNull] object Foo() {
 35 |   ///   return null; // Warning: Possible 'null' assignment
 36 |   /// }
 37 |   /// </code></example>
 38 |   [AttributeUsage(
 39 |     AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
 40 |     AttributeTargets.Delegate | AttributeTargets.Field | AttributeTargets.Event)]
 41 |   public sealed class NotNullAttribute : Attribute { }
 42 | 
 43 |   /// <summary>
 44 |   /// Can be appplied to symbols of types derived from IEnumerable as well as to symbols of Task
 45 |   /// and Lazy classes to indicate that the value of a collection item, of the Task.Result property
 46 |   /// or of the Lazy.Value property can never be null.
 47 |   /// </summary>
 48 |   [AttributeUsage(
 49 |     AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
 50 |     AttributeTargets.Delegate | AttributeTargets.Field)]
 51 |   public sealed class ItemNotNullAttribute : Attribute { }
 52 | 
 53 |   /// <summary>
 54 |   /// Can be appplied to symbols of types derived from IEnumerable as well as to symbols of Task
 55 |   /// and Lazy classes to indicate that the value of a collection item, of the Task.Result property
 56 |   /// or of the Lazy.Value property can be null.
 57 |   /// </summary>
 58 |   [AttributeUsage(
 59 |     AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
 60 |     AttributeTargets.Delegate | AttributeTargets.Field)]
 61 |   public sealed class ItemCanBeNullAttribute : Attribute { }
 62 | 
 63 |   /// <summary>
 64 |   /// Indicates that the marked method builds string by format pattern and (optional) arguments.
 65 |   /// Parameter, which contains format string, should be given in constructor. The format string
 66 |   /// should be in <see cref="string.Format(IFormatProvider,string,object[])"/>-like form.
 67 |   /// </summary>
 68 |   /// <example><code>
 69 |   /// [StringFormatMethod("message")]
 70 |   /// void ShowError(string message, params object[] args) { /* do something */ }
 71 |   /// 
 72 |   /// void Foo() {
 73 |   ///   ShowError("Failed: {0}"); // Warning: Non-existing argument in format string
 74 |   /// }
 75 |   /// </code></example>
 76 |   [AttributeUsage(
 77 |     AttributeTargets.Constructor | AttributeTargets.Method |
 78 |     AttributeTargets.Property | AttributeTargets.Delegate)]
 79 |   public sealed class StringFormatMethodAttribute : Attribute
 80 |   {
 81 |     /// <param name="formatParameterName">
 82 |     /// Specifies which parameter of an annotated method should be treated as format-string
 83 |     /// </param>
 84 |     public StringFormatMethodAttribute(string formatParameterName)
 85 |     {
 86 |       FormatParameterName = formatParameterName;
 87 |     }
 88 | 
 89 |     public string FormatParameterName { get; private set; }
 90 |   }
 91 | 
 92 |   /// <summary>
 93 |   /// For a parameter that is expected to be one of the limited set of values.
 94 |   /// Specify fields of which type should be used as values for this parameter.
 95 |   /// </summary>
 96 |   [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.Field)]
 97 |   public sealed class ValueProviderAttribute : Attribute
 98 |   {
 99 |     public ValueProviderAttribute(string name)
100 |     {
101 |       Name = name;
102 |     }
103 | 
104 |     [NotNull] public string Name { get; private set; }
105 |   }
106 | 
107 |   /// <summary>
108 |   /// Indicates that the function argument should be string literal and match one
109 |   /// of the parameters of the caller function. For example, ReSharper annotates
110 |   /// the parameter of <see cref="System.ArgumentNullException"/>.
111 |   /// </summary>
112 |   /// <example><code>
113 |   /// void Foo(string param) {
114 |   ///   if (param == null)
115 |   ///     throw new ArgumentNullException("par"); // Warning: Cannot resolve symbol
116 |   /// }
117 |   /// </code></example>
118 |   [AttributeUsage(AttributeTargets.Parameter)]
119 |   public sealed class InvokerParameterNameAttribute : Attribute { }
120 | 
121 |   /// <summary>
122 |   /// Indicates that the method is contained in a type that implements
123 |   /// <c>System.ComponentModel.INotifyPropertyChanged</c> interface and this method
124 |   /// is used to notify that some property value changed.
125 |   /// </summary>
126 |   /// <remarks>
127 |   /// The method should be non-static and conform to one of the supported signatures:
128 |   /// <list>
129 |   /// <item><c>NotifyChanged(string)</c></item>
130 |   /// <item><c>NotifyChanged(params string[])</c></item>
131 |   /// <item><c>NotifyChanged{T}(Expression{Func{T}})</c></item>
132 |   /// <item><c>NotifyChanged{T,U}(Expression{Func{T,U}})</c></item>
133 |   /// <item><c>SetProperty{T}(ref T, T, string)</c></item>
134 |   /// </list>
135 |   /// </remarks>
136 |   /// <example><code>
137 |   /// public class Foo : INotifyPropertyChanged {
138 |   ///   public event PropertyChangedEventHandler PropertyChanged;
139 |   /// 
140 |   ///   [NotifyPropertyChangedInvocator]
141 |   ///   protected virtual void NotifyChanged(string propertyName) { ... }
142 |   ///
143 |   ///   string _name;
144 |   /// 
145 |   ///   public string Name {
146 |   ///     get { return _name; }
147 |   ///     set { _name = value; NotifyChanged("LastName"); /* Warning */ }
148 |   ///   }
149 |   /// }
150 |   /// </code>
151 |   /// Examples of generated notifications:
152 |   /// <list>
153 |   /// <item><c>NotifyChanged("Property")</c></item>
154 |   /// <item><c>NotifyChanged(() =&gt; Property)</c></item>
155 |   /// <item><c>NotifyChanged((VM x) =&gt; x.Property)</c></item>
156 |   /// <item><c>SetProperty(ref myField, value, "Property")</c></item>
157 |   /// </list>
158 |   /// </example>
159 |   [AttributeUsage(AttributeTargets.Method)]
160 |   public sealed class NotifyPropertyChangedInvocatorAttribute : Attribute
161 |   {
162 |     public NotifyPropertyChangedInvocatorAttribute() { }
163 |     public NotifyPropertyChangedInvocatorAttribute(string parameterName)
164 |     {
165 |       ParameterName = parameterName;
166 |     }
167 | 
168 |     public string ParameterName { get; private set; }
169 |   }
170 | 
171 |   /// <summary>
172 |   /// Describes dependency between method input and output.
173 |   /// </summary>
174 |   /// <syntax>
175 |   /// <p>Function Definition Table syntax:</p>
176 |   /// <list>
177 |   /// <item>FDT      ::= FDTRow [;FDTRow]*</item>
178 |   /// <item>FDTRow   ::= Input =&gt; Output | Output &lt;= Input</item>
179 |   /// <item>Input    ::= ParameterName: Value [, Input]*</item>
180 |   /// <item>Output   ::= [ParameterName: Value]* {halt|stop|void|nothing|Value}</item>
181 |   /// <item>Value    ::= true | false | null | notnull | canbenull</item>
182 |   /// </list>
183 |   /// If method has single input parameter, it's name could be omitted.<br/>
184 |   /// Using <c>halt</c> (or <c>void</c>/<c>nothing</c>, which is the same)
185 |   /// for method output means that the methos doesn't return normally.<br/>
186 |   /// <c>canbenull</c> annotation is only applicable for output parameters.<br/>
187 |   /// You can use multiple <c>[ContractAnnotation]</c> for each FDT row,
188 |   /// or use single attribute with rows separated by semicolon.<br/>
189 |   /// </syntax>
190 |   /// <examples><list>
191 |   /// <item><code>
192 |   /// [ContractAnnotation("=> halt")]
193 |   /// public void TerminationMethod()
194 |   /// </code></item>
195 |   /// <item><code>
196 |   /// [ContractAnnotation("halt &lt;= condition: false")]
197 |   /// public void Assert(bool condition, string text) // regular assertion method
198 |   /// </code></item>
199 |   /// <item><code>
200 |   /// [ContractAnnotation("s:null => true")]
201 |   /// public bool IsNullOrEmpty(string s) // string.IsNullOrEmpty()
202 |   /// </code></item>
203 |   /// <item><code>
204 |   /// // A method that returns null if the parameter is null,
205 |   /// // and not null if the parameter is not null
206 |   /// [ContractAnnotation("null => null; notnull => notnull")]
207 |   /// public object Transform(object data) 
208 |   /// </code></item>
209 |   /// <item><code>
210 |   /// [ContractAnnotation("s:null=>false; =>true,result:notnull; =>false, result:null")]
211 |   /// public bool TryParse(string s, out Person result)
212 |   /// </code></item>
213 |   /// </list></examples>
214 |   [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
215 |   public sealed class ContractAnnotationAttribute : Attribute
216 |   {
217 |     public ContractAnnotationAttribute([NotNull] string contract)
218 |       : this(contract, false) { }
219 | 
220 |     public ContractAnnotationAttribute([NotNull] string contract, bool forceFullStates)
221 |     {
222 |       Contract = contract;
223 |       ForceFullStates = forceFullStates;
224 |     }
225 | 
226 |     public string Contract { get; private set; }
227 |     public bool ForceFullStates { get; private set; }
228 |   }
229 | 
230 |   /// <summary>
231 |   /// Indicates that marked element should be localized or not.
232 |   /// </summary>
233 |   /// <example><code>
234 |   /// [LocalizationRequiredAttribute(true)]
235 |   /// class Foo {
236 |   ///   string str = "my string"; // Warning: Localizable string
237 |   /// }
238 |   /// </code></example>
239 |   [AttributeUsage(AttributeTargets.All)]
240 |   public sealed class LocalizationRequiredAttribute : Attribute
241 |   {
242 |     public LocalizationRequiredAttribute() : this(true) { }
243 |     public LocalizationRequiredAttribute(bool required)
244 |     {
245 |       Required = required;
246 |     }
247 | 
248 |     public bool Required { get; private set; }
249 |   }
250 | 
251 |   /// <summary>
252 |   /// Indicates that the value of the marked type (or its derivatives)
253 |   /// cannot be compared using '==' or '!=' operators and <c>Equals()</c>
254 |   /// should be used instead. However, using '==' or '!=' for comparison
255 |   /// with <c>null</c> is always permitted.
256 |   /// </summary>
257 |   /// <example><code>
258 |   /// [CannotApplyEqualityOperator]
259 |   /// class NoEquality { }
260 |   /// 
261 |   /// class UsesNoEquality {
262 |   ///   void Test() {
263 |   ///     var ca1 = new NoEquality();
264 |   ///     var ca2 = new NoEquality();
265 |   ///     if (ca1 != null) { // OK
266 |   ///       bool condition = ca1 == ca2; // Warning
267 |   ///     }
268 |   ///   }
269 |   /// }
270 |   /// </code></example>
271 |   [AttributeUsage(AttributeTargets.Interface | AttributeTargets.Class | AttributeTargets.Struct)]
272 |   public sealed class CannotApplyEqualityOperatorAttribute : Attribute { }
273 | 
274 |   /// <summary>
275 |   /// When applied to a target attribute, specifies a requirement for any type marked
276 |   /// with the target attribute to implement or inherit specific type or types.
277 |   /// </summary>
278 |   /// <example><code>
279 |   /// [BaseTypeRequired(typeof(IComponent)] // Specify requirement
280 |   /// class ComponentAttribute : Attribute { }
281 |   /// 
282 |   /// [Component] // ComponentAttribute requires implementing IComponent interface
283 |   /// class MyComponent : IComponent { }
284 |   /// </code></example>
285 |   [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
286 |   [BaseTypeRequired(typeof(Attribute))]
287 |   public sealed class BaseTypeRequiredAttribute : Attribute
288 |   {
289 |     public BaseTypeRequiredAttribute([NotNull] Type baseType)
290 |     {
291 |       BaseType = baseType;
292 |     }
293 | 
294 |     [NotNull] public Type BaseType { get; private set; }
295 |   }
296 | 
297 |   /// <summary>
298 |   /// Indicates that the marked symbol is used implicitly (e.g. via reflection, in external library),
299 |   /// so this symbol will not be marked as unused (as well as by other usage inspections).
300 |   /// </summary>
301 |   [AttributeUsage(AttributeTargets.All)]
302 |   public sealed class UsedImplicitlyAttribute : Attribute
303 |   {
304 |     public UsedImplicitlyAttribute()
305 |       : this(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Default) { }
306 | 
307 |     public UsedImplicitlyAttribute(ImplicitUseKindFlags useKindFlags)
308 |       : this(useKindFlags, ImplicitUseTargetFlags.Default) { }
309 | 
310 |     public UsedImplicitlyAttribute(ImplicitUseTargetFlags targetFlags)
311 |       : this(ImplicitUseKindFlags.Default, targetFlags) { }
312 | 
313 |     public UsedImplicitlyAttribute(ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags)
314 |     {
315 |       UseKindFlags = useKindFlags;
316 |       TargetFlags = targetFlags;
317 |     }
318 | 
319 |     public ImplicitUseKindFlags UseKindFlags { get; private set; }
320 |     public ImplicitUseTargetFlags TargetFlags { get; private set; }
321 |   }
322 | 
323 |   /// <summary>
324 |   /// Should be used on attributes and causes ReSharper to not mark symbols marked with such attributes
325 |   /// as unused (as well as by other usage inspections)
326 |   /// </summary>
327 |   [AttributeUsage(AttributeTargets.Class | AttributeTargets.GenericParameter)]
328 |   public sealed class MeansImplicitUseAttribute : Attribute
329 |   {
330 |     public MeansImplicitUseAttribute()
331 |       : this(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Default) { }
332 | 
333 |     public MeansImplicitUseAttribute(ImplicitUseKindFlags useKindFlags)
334 |       : this(useKindFlags, ImplicitUseTargetFlags.Default) { }
335 | 
336 |     public MeansImplicitUseAttribute(ImplicitUseTargetFlags targetFlags)
337 |       : this(ImplicitUseKindFlags.Default, targetFlags) { }
338 | 
339 |     public MeansImplicitUseAttribute(ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags)
340 |     {
341 |       UseKindFlags = useKindFlags;
342 |       TargetFlags = targetFlags;
343 |     }
344 | 
345 |     [UsedImplicitly] public ImplicitUseKindFlags UseKindFlags { get; private set; }
346 |     [UsedImplicitly] public ImplicitUseTargetFlags TargetFlags { get; private set; }
347 |   }
348 | 
349 |   [Flags]
350 |   public enum ImplicitUseKindFlags
351 |   {
352 |     Default = Access | Assign | InstantiatedWithFixedConstructorSignature,
353 |     /// <summary>Only entity marked with attribute considered used.</summary>
354 |     Access = 1,
355 |     /// <summary>Indicates implicit assignment to a member.</summary>
356 |     Assign = 2,
357 |     /// <summary>
358 |     /// Indicates implicit instantiation of a type with fixed constructor signature.
359 |     /// That means any unused constructor parameters won't be reported as such.
360 |     /// </summary>
361 |     InstantiatedWithFixedConstructorSignature = 4,
362 |     /// <summary>Indicates implicit instantiation of a type.</summary>
363 |     InstantiatedNoFixedConstructorSignature = 8,
364 |   }
365 | 
366 |   /// <summary>
367 |   /// Specify what is considered used implicitly when marked
368 |   /// with <see cref="MeansImplicitUseAttribute"/> or <see cref="UsedImplicitlyAttribute"/>.
369 |   /// </summary>
370 |   [Flags]
371 |   public enum ImplicitUseTargetFlags
372 |   {
373 |     Default = Itself,
374 |     Itself = 1,
375 |     /// <summary>Members of entity marked with attribute are considered used.</summary>
376 |     Members = 2,
377 |     /// <summary>Entity marked with attribute and all its members considered used.</summary>
378 |     WithMembers = Itself | Members
379 |   }
380 | 
381 |   /// <summary>
382 |   /// This attribute is intended to mark publicly available API
383 |   /// which should not be removed and so is treated as used.
384 |   /// </summary>
385 |   [MeansImplicitUse(ImplicitUseTargetFlags.WithMembers)]
386 |   public sealed class PublicAPIAttribute : Attribute
387 |   {
388 |     public PublicAPIAttribute() { }
389 |     public PublicAPIAttribute([NotNull] string comment)
390 |     {
391 |       Comment = comment;
392 |     }
393 | 
394 |     public string Comment { get; private set; }
395 |   }
396 | 
397 |   /// <summary>
398 |   /// Tells code analysis engine if the parameter is completely handled when the invoked method is on stack.
399 |   /// If the parameter is a delegate, indicates that delegate is executed while the method is executed.
400 |   /// If the parameter is an enumerable, indicates that it is enumerated while the method is executed.
401 |   /// </summary>
402 |   [AttributeUsage(AttributeTargets.Parameter)]
403 |   public sealed class InstantHandleAttribute : Attribute { }
404 | 
405 |   /// <summary>
406 |   /// Indicates that a method does not make any observable state changes.
407 |   /// The same as <c>System.Diagnostics.Contracts.PureAttribute</c>.
408 |   /// </summary>
409 |   /// <example><code>
410 |   /// [Pure] int Multiply(int x, int y) => x * y;
411 |   /// 
412 |   /// void M() {
413 |   ///   Multiply(123, 42); // Waring: Return value of pure method is not used
414 |   /// }
415 |   /// </code></example>
416 |   [AttributeUsage(AttributeTargets.Method)]
417 |   public sealed class PureAttribute : Attribute { }
418 | 
419 |   /// <summary>
420 |   /// Indicates that the return value of method invocation must be used.
421 |   /// </summary>
422 |   [AttributeUsage(AttributeTargets.Method)]
423 |   public sealed class MustUseReturnValueAttribute : Attribute
424 |   {
425 |     public MustUseReturnValueAttribute() { }
426 |     public MustUseReturnValueAttribute([NotNull] string justification)
427 |     {
428 |       Justification = justification;
429 |     }
430 | 
431 |     public string Justification { get; private set; }
432 |   }
433 | 
434 |   /// <summary>
435 |   /// Indicates the type member or parameter of some type, that should be used instead of all other ways
436 |   /// to get the value that type. This annotation is useful when you have some "context" value evaluated
437 |   /// and stored somewhere, meaning that all other ways to get this value must be consolidated with existing one.
438 |   /// </summary>
439 |   /// <example><code>
440 |   /// class Foo {
441 |   ///   [ProvidesContext] IBarService _barService = ...;
442 |   /// 
443 |   ///   void ProcessNode(INode node) {
444 |   ///     DoSomething(node, node.GetGlobalServices().Bar);
445 |   ///     //              ^ Warning: use value of '_barService' field
446 |   ///   }
447 |   /// }
448 |   /// </code></example>
449 |   [AttributeUsage(
450 |     AttributeTargets.Field | AttributeTargets.Property | AttributeTargets.Parameter |
451 |     AttributeTargets.Method)]
452 |   public sealed class ProvidesContextAttribute : Attribute { }
453 | 
454 |   /// <summary>
455 |   /// Indicates that a parameter is a path to a file or a folder within a web project.
456 |   /// Path can be relative or absolute, starting from web root (~).
457 |   /// </summary>
458 |   [AttributeUsage(AttributeTargets.Parameter)]
459 |   public sealed class PathReferenceAttribute : Attribute
460 |   {
461 |     public PathReferenceAttribute() { }
462 |     public PathReferenceAttribute([PathReference] string basePath)
463 |     {
464 |       BasePath = basePath;
465 |     }
466 | 
467 |     public string BasePath { get; private set; }
468 |   }
469 | 
470 |   /// <summary>
471 |   /// An extension method marked with this attribute is processed by ReSharper code completion
472 |   /// as a 'Source Template'. When extension method is completed over some expression, it's source code
473 |   /// is automatically expanded like a template at call site.
474 |   /// </summary>
475 |   /// <remarks>
476 |   /// Template method body can contain valid source code and/or special comments starting with '$'.
477 |   /// Text inside these comments is added as source code when the template is applied. Template parameters
478 |   /// can be used either as additional method parameters or as identifiers wrapped in two '$' signs.
479 |   /// Use the <see cref="MacroAttribute"/> attribute to specify macros for parameters.
480 |   /// </remarks>
481 |   /// <example>
482 |   /// In this example, the 'forEach' method is a source template available over all values
483 |   /// of enumerable types, producing ordinary C# 'foreach' statement and placing caret inside block:
484 |   /// <code>
485 |   /// [SourceTemplate]
486 |   /// public static void forEach&lt;T&gt;(this IEnumerable&lt;T&gt; xs) {
487 |   ///   foreach (var x in xs) {
488 |   ///      //$ $END$
489 |   ///   }
490 |   /// }
491 |   /// </code>
492 |   /// </example>
493 |   [AttributeUsage(AttributeTargets.Method)]
494 |   public sealed class SourceTemplateAttribute : Attribute { }
495 | 
496 |   /// <summary>
497 |   /// Allows specifying a macro for a parameter of a <see cref="SourceTemplateAttribute">source template</see>.
498 |   /// </summary>
499 |   /// <remarks>
500 |   /// You can apply the attribute on the whole method or on any of its additional parameters. The macro expression
501 |   /// is defined in the <see cref="MacroAttribute.Expression"/> property. When applied on a method, the target
502 |   /// template parameter is defined in the <see cref="MacroAttribute.Target"/> property. To apply the macro silently
503 |   /// for the parameter, set the <see cref="MacroAttribute.Editable"/> property value = -1.
504 |   /// </remarks>
505 |   /// <example>
506 |   /// Applying the attribute on a source template method:
507 |   /// <code>
508 |   /// [SourceTemplate, Macro(Target = "item", Expression = "suggestVariableName()")]
509 |   /// public static void forEach&lt;T&gt;(this IEnumerable&lt;T&gt; collection) {
510 |   ///   foreach (var item in collection) {
511 |   ///     //$ $END$
512 |   ///   }
513 |   /// }
514 |   /// </code>
515 |   /// Applying the attribute on a template method parameter:
516 |   /// <code>
517 |   /// [SourceTemplate]
518 |   /// public static void something(this Entity x, [Macro(Expression = "guid()", Editable = -1)] string newguid) {
519 |   ///   /*$ var $x$Id = "$newguid$" + x.ToString();
520 |   ///   x.DoSomething($x$Id); */
521 |   /// }
522 |   /// </code>
523 |   /// </example>
524 |   [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method, AllowMultiple = true)]
525 |   public sealed class MacroAttribute : Attribute
526 |   {
527 |     /// <summary>
528 |     /// Allows specifying a macro that will be executed for a <see cref="SourceTemplateAttribute">source template</see>
529 |     /// parameter when the template is expanded.
530 |     /// </summary>
531 |     public string Expression { get; set; }
532 | 
533 |     /// <summary>
534 |     /// Allows specifying which occurrence of the target parameter becomes editable when the template is deployed.
535 |     /// </summary>
536 |     /// <remarks>
537 |     /// If the target parameter is used several times in the template, only one occurrence becomes editable;
538 |     /// other occurrences are changed synchronously. To specify the zero-based index of the editable occurrence,
539 |     /// use values >= 0. To make the parameter non-editable when the template is expanded, use -1.
540 |     /// </remarks>>
541 |     public int Editable { get; set; }
542 | 
543 |     /// <summary>
544 |     /// Identifies the target parameter of a <see cref="SourceTemplateAttribute">source template</see> if the
545 |     /// <see cref="MacroAttribute"/> is applied on a template method.
546 |     /// </summary>
547 |     public string Target { get; set; }
548 |   }
549 | 
550 |   [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
551 |   public sealed class AspMvcAreaMasterLocationFormatAttribute : Attribute
552 |   {
553 |     public AspMvcAreaMasterLocationFormatAttribute(string format)
554 |     {
555 |       Format = format;
556 |     }
557 | 
558 |     public string Format { get; private set; }
559 |   }
560 | 
561 |   [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
562 |   public sealed class AspMvcAreaPartialViewLocationFormatAttribute : Attribute
563 |   {
564 |     public AspMvcAreaPartialViewLocationFormatAttribute(string format)
565 |     {
566 |       Format = format;
567 |     }
568 | 
569 |     public string Format { get; private set; }
570 |   }
571 | 
572 |   [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
573 |   public sealed class AspMvcAreaViewLocationFormatAttribute : Attribute
574 |   {
575 |     public AspMvcAreaViewLocationFormatAttribute(string format)
576 |     {
577 |       Format = format;
578 |     }
579 | 
580 |     public string Format { get; private set; }
581 |   }
582 | 
583 |   [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
584 |   public sealed class AspMvcMasterLocationFormatAttribute : Attribute
585 |   {
586 |     public AspMvcMasterLocationFormatAttribute(string format)
587 |     {
588 |       Format = format;
589 |     }
590 | 
591 |     public string Format { get; private set; }
592 |   }
593 | 
594 |   [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
595 |   public sealed class AspMvcPartialViewLocationFormatAttribute : Attribute
596 |   {
597 |     public AspMvcPartialViewLocationFormatAttribute(string format)
598 |     {
599 |       Format = format;
600 |     }
601 | 
602 |     public string Format { get; private set; }
603 |   }
604 | 
605 |   [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
606 |   public sealed class AspMvcViewLocationFormatAttribute : Attribute
607 |   {
608 |     public AspMvcViewLocationFormatAttribute(string format)
609 |     {
610 |       Format = format;
611 |     }
612 | 
613 |     public string Format { get; private set; }
614 |   }
615 | 
616 |   /// <summary>
617 |   /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
618 |   /// is an MVC action. If applied to a method, the MVC action name is calculated
619 |   /// implicitly from the context. Use this attribute for custom wrappers similar to
620 |   /// <c>System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String)</c>.
621 |   /// </summary>
622 |   [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)]
623 |   public sealed class AspMvcActionAttribute : Attribute
624 |   {
625 |     public AspMvcActionAttribute() { }
626 |     public AspMvcActionAttribute(string anonymousProperty)
627 |     {
628 |       AnonymousProperty = anonymousProperty;
629 |     }
630 | 
631 |     public string AnonymousProperty { get; private set; }
632 |   }
633 | 
634 |   /// <summary>
635 |   /// ASP.NET MVC attribute. Indicates that a parameter is an MVC area.
636 |   /// Use this attribute for custom wrappers similar to
637 |   /// <c>System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String)</c>.
638 |   /// </summary>
639 |   [AttributeUsage(AttributeTargets.Parameter)]
640 |   public sealed class AspMvcAreaAttribute : Attribute
641 |   {
642 |     public AspMvcAreaAttribute() { }
643 |     public AspMvcAreaAttribute(string anonymousProperty)
644 |     {
645 |       AnonymousProperty = anonymousProperty;
646 |     }
647 | 
648 |     public string AnonymousProperty { get; private set; }
649 |   }
650 | 
651 |   /// <summary>
652 |   /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter is
653 |   /// an MVC controller. If applied to a method, the MVC controller name is calculated
654 |   /// implicitly from the context. Use this attribute for custom wrappers similar to
655 |   /// <c>System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String, String)</c>.
656 |   /// </summary>
657 |   [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)]
658 |   public sealed class AspMvcControllerAttribute : Attribute
659 |   {
660 |     public AspMvcControllerAttribute() { }
661 |     public AspMvcControllerAttribute(string anonymousProperty)
662 |     {
663 |       AnonymousProperty = anonymousProperty;
664 |     }
665 | 
666 |     public string AnonymousProperty { get; private set; }
667 |   }
668 | 
669 |   /// <summary>
670 |   /// ASP.NET MVC attribute. Indicates that a parameter is an MVC Master. Use this attribute
671 |   /// for custom wrappers similar to <c>System.Web.Mvc.Controller.View(String, String)</c>.
672 |   /// </summary>
673 |   [AttributeUsage(AttributeTargets.Parameter)]
674 |   public sealed class AspMvcMasterAttribute : Attribute { }
675 | 
676 |   /// <summary>
677 |   /// ASP.NET MVC attribute. Indicates that a parameter is an MVC model type. Use this attribute
678 |   /// for custom wrappers similar to <c>System.Web.Mvc.Controller.View(String, Object)</c>.
679 |   /// </summary>
680 |   [AttributeUsage(AttributeTargets.Parameter)]
681 |   public sealed class AspMvcModelTypeAttribute : Attribute { }
682 | 
683 |   /// <summary>
684 |   /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter is an MVC
685 |   /// partial view. If applied to a method, the MVC partial view name is calculated implicitly
686 |   /// from the context. Use this attribute for custom wrappers similar to
687 |   /// <c>System.Web.Mvc.Html.RenderPartialExtensions.RenderPartial(HtmlHelper, String)</c>.
688 |   /// </summary>
689 |   [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)]
690 |   public sealed class AspMvcPartialViewAttribute : Attribute { }
691 | 
692 |   /// <summary>
693 |   /// ASP.NET MVC attribute. Allows disabling inspections for MVC views within a class or a method.
694 |   /// </summary>
695 |   [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
696 |   public sealed class AspMvcSuppressViewErrorAttribute : Attribute { }
697 | 
698 |   /// <summary>
699 |   /// ASP.NET MVC attribute. Indicates that a parameter is an MVC display template.
700 |   /// Use this attribute for custom wrappers similar to 
701 |   /// <c>System.Web.Mvc.Html.DisplayExtensions.DisplayForModel(HtmlHelper, String)</c>.
702 |   /// </summary>
703 |   [AttributeUsage(AttributeTargets.Parameter)]
704 |   public sealed class AspMvcDisplayTemplateAttribute : Attribute { }
705 | 
706 |   /// <summary>
707 |   /// ASP.NET MVC attribute. Indicates that a parameter is an MVC editor template.
708 |   /// Use this attribute for custom wrappers similar to
709 |   /// <c>System.Web.Mvc.Html.EditorExtensions.EditorForModel(HtmlHelper, String)</c>.
710 |   /// </summary>
711 |   [AttributeUsage(AttributeTargets.Parameter)]
712 |   public sealed class AspMvcEditorTemplateAttribute : Attribute { }
713 | 
714 |   /// <summary>
715 |   /// ASP.NET MVC attribute. Indicates that a parameter is an MVC template.
716 |   /// Use this attribute for custom wrappers similar to
717 |   /// <c>System.ComponentModel.DataAnnotations.UIHintAttribute(System.String)</c>.
718 |   /// </summary>
719 |   [AttributeUsage(AttributeTargets.Parameter)]
720 |   public sealed class AspMvcTemplateAttribute : Attribute { }
721 | 
722 |   /// <summary>
723 |   /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
724 |   /// is an MVC view component. If applied to a method, the MVC view name is calculated implicitly
725 |   /// from the context. Use this attribute for custom wrappers similar to
726 |   /// <c>System.Web.Mvc.Controller.View(Object)</c>.
727 |   /// </summary>
728 |   [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)]
729 |   public sealed class AspMvcViewAttribute : Attribute { }
730 | 
731 |   /// <summary>
732 |   /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
733 |   /// is an MVC view component name.
734 |   /// </summary>
735 |   [AttributeUsage(AttributeTargets.Parameter)]
736 |   public sealed class AspMvcViewComponentAttribute : Attribute { }
737 | 
738 |   /// <summary>
739 |   /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
740 |   /// is an MVC view component view. If applied to a method, the MVC view component view name is default.
741 |   /// </summary>
742 |   [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)]
743 |   public sealed class AspMvcViewComponentViewAttribute : Attribute { }
744 | 
745 |   /// <summary>
746 |   /// ASP.NET MVC attribute. When applied to a parameter of an attribute,
747 |   /// indicates that this parameter is an MVC action name.
748 |   /// </summary>
749 |   /// <example><code>
750 |   /// [ActionName("Foo")]
751 |   /// public ActionResult Login(string returnUrl) {
752 |   ///   ViewBag.ReturnUrl = Url.Action("Foo"); // OK
753 |   ///   return RedirectToAction("Bar"); // Error: Cannot resolve action
754 |   /// }
755 |   /// </code></example>
756 |   [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property)]
757 |   public sealed class AspMvcActionSelectorAttribute : Attribute { }
758 | 
759 |   [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.Field)]
760 |   public sealed class HtmlElementAttributesAttribute : Attribute
761 |   {
762 |     public HtmlElementAttributesAttribute() { }
763 |     public HtmlElementAttributesAttribute(string name)
764 |     {
765 |       Name = name;
766 |     }
767 | 
768 |     public string Name { get; private set; }
769 |   }
770 | 
771 |   [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
772 |   public sealed class HtmlAttributeValueAttribute : Attribute
773 |   {
774 |     public HtmlAttributeValueAttribute([NotNull] string name)
775 |     {
776 |       Name = name;
777 |     }
778 | 
779 |     [NotNull] public string Name { get; private set; }
780 |   }
781 | 
782 |   /// <summary>
783 |   /// Razor attribute. Indicates that a parameter or a method is a Razor section.
784 |   /// Use this attribute for custom wrappers similar to 
785 |   /// <c>System.Web.WebPages.WebPageBase.RenderSection(String)</c>.
786 |   /// </summary>
787 |   [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)]
788 |   public sealed class RazorSectionAttribute : Attribute { }
789 | 
790 |   /// <summary>
791 |   /// Indicates how method, constructor invocation or property access
792 |   /// over collection type affects content of the collection.
793 |   /// </summary>
794 |   [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Property)]
795 |   public sealed class CollectionAccessAttribute : Attribute
796 |   {
797 |     public CollectionAccessAttribute(CollectionAccessType collectionAccessType)
798 |     {
799 |       CollectionAccessType = collectionAccessType;
800 |     }
801 | 
802 |     public CollectionAccessType CollectionAccessType { get; private set; }
803 |   }
804 | 
805 |   [Flags]
806 |   public enum CollectionAccessType
807 |   {
808 |     /// <summary>Method does not use or modify content of the collection.</summary>
809 |     None = 0,
810 |     /// <summary>Method only reads content of the collection but does not modify it.</summary>
811 |     Read = 1,
812 |     /// <summary>Method can change content of the collection but does not add new elements.</summary>
813 |     ModifyExistingContent = 2,
814 |     /// <summary>Method can add new elements to the collection.</summary>
815 |     UpdatedContent = ModifyExistingContent | 4
816 |   }
817 | 
818 |   /// <summary>
819 |   /// Indicates that the marked method is assertion method, i.e. it halts control flow if
820 |   /// one of the conditions is satisfied. To set the condition, mark one of the parameters with 
821 |   /// <see cref="AssertionConditionAttribute"/> attribute.
822 |   /// </summary>
823 |   [AttributeUsage(AttributeTargets.Method)]
824 |   public sealed class AssertionMethodAttribute : Attribute { }
825 | 
826 |   /// <summary>
827 |   /// Indicates the condition parameter of the assertion method. The method itself should be
828 |   /// marked by <see cref="AssertionMethodAttribute"/> attribute. The mandatory argument of
829 |   /// the attribute is the assertion type.
830 |   /// </summary>
831 |   [AttributeUsage(AttributeTargets.Parameter)]
832 |   public sealed class AssertionConditionAttribute : Attribute
833 |   {
834 |     public AssertionConditionAttribute(AssertionConditionType conditionType)
835 |     {
836 |       ConditionType = conditionType;
837 |     }
838 | 
839 |     public AssertionConditionType ConditionType { get; private set; }
840 |   }
841 | 
842 |   /// <summary>
843 |   /// Specifies assertion type. If the assertion method argument satisfies the condition,
844 |   /// then the execution continues. Otherwise, execution is assumed to be halted.
845 |   /// </summary>
846 |   public enum AssertionConditionType
847 |   {
848 |     /// <summary>Marked parameter should be evaluated to true.</summary>
849 |     IS_TRUE = 0,
850 |     /// <summary>Marked parameter should be evaluated to false.</summary>
851 |     IS_FALSE = 1,
852 |     /// <summary>Marked parameter should be evaluated to null value.</summary>
853 |     IS_NULL = 2,
854 |     /// <summary>Marked parameter should be evaluated to not null value.</summary>
855 |     IS_NOT_NULL = 3,
856 |   }
857 | 
858 |   /// <summary>
859 |   /// Indicates that the marked method unconditionally terminates control flow execution.
860 |   /// For example, it could unconditionally throw exception.
861 |   /// </summary>
862 |   [Obsolete("Use [ContractAnnotation('=> halt')] instead")]
863 |   [AttributeUsage(AttributeTargets.Method)]
864 |   public sealed class TerminatesProgramAttribute : Attribute { }
865 | 
866 |   /// <summary>
867 |   /// Indicates that method is pure LINQ method, with postponed enumeration (like Enumerable.Select,
868 |   /// .Where). This annotation allows inference of [InstantHandle] annotation for parameters
869 |   /// of delegate type by analyzing LINQ method chains.
870 |   /// </summary>
871 |   [AttributeUsage(AttributeTargets.Method)]
872 |   public sealed class LinqTunnelAttribute : Attribute { }
873 | 
874 |   /// <summary>
875 |   /// Indicates that IEnumerable, passed as parameter, is not enumerated.
876 |   /// </summary>
877 |   [AttributeUsage(AttributeTargets.Parameter)]
878 |   public sealed class NoEnumerationAttribute : Attribute { }
879 | 
880 |   /// <summary>
881 |   /// Indicates that parameter is regular expression pattern.
882 |   /// </summary>
883 |   [AttributeUsage(AttributeTargets.Parameter)]
884 |   public sealed class RegexPatternAttribute : Attribute { }
885 | 
886 |   /// <summary>
887 |   /// XAML attribute. Indicates the type that has <c>ItemsSource</c> property and should be treated
888 |   /// as <c>ItemsControl</c>-derived type, to enable inner items <c>DataContext</c> type resolve.
889 |   /// </summary>
890 |   [AttributeUsage(AttributeTargets.Class)]
891 |   public sealed class XamlItemsControlAttribute : Attribute { }
892 | 
893 |   /// <summary>
894 |   /// XAML attribute. Indicates the property of some <c>BindingBase</c>-derived type, that
895 |   /// is used to bind some item of <c>ItemsControl</c>-derived type. This annotation will
896 |   /// enable the <c>DataContext</c> type resolve for XAML bindings for such properties.
897 |   /// </summary>
898 |   /// <remarks>
899 |   /// Property should have the tree ancestor of the <c>ItemsControl</c> type or
900 |   /// marked with the <see cref="XamlItemsControlAttribute"/> attribute.
901 |   /// </remarks>
902 |   [AttributeUsage(AttributeTargets.Property)]
903 |   public sealed class XamlItemBindingOfItemsControlAttribute : Attribute { }
904 | 
905 |   [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
906 |   public sealed class AspChildControlTypeAttribute : Attribute
907 |   {
908 |     public AspChildControlTypeAttribute(string tagName, Type controlType)
909 |     {
910 |       TagName = tagName;
911 |       ControlType = controlType;
912 |     }
913 | 
914 |     public string TagName { get; private set; }
915 |     public Type ControlType { get; private set; }
916 |   }
917 | 
918 |   [AttributeUsage(AttributeTargets.Property | AttributeTargets.Method)]
919 |   public sealed class AspDataFieldAttribute : Attribute { }
920 | 
921 |   [AttributeUsage(AttributeTargets.Property | AttributeTargets.Method)]
922 |   public sealed class AspDataFieldsAttribute : Attribute { }
923 | 
924 |   [AttributeUsage(AttributeTargets.Property)]
925 |   public sealed class AspMethodPropertyAttribute : Attribute { }
926 | 
927 |   [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
928 |   public sealed class AspRequiredAttributeAttribute : Attribute
929 |   {
930 |     public AspRequiredAttributeAttribute([NotNull] string attribute)
931 |     {
932 |       Attribute = attribute;
933 |     }
934 | 
935 |     public string Attribute { get; private set; }
936 |   }
937 | 
938 |   [AttributeUsage(AttributeTargets.Property)]
939 |   public sealed class AspTypePropertyAttribute : Attribute
940 |   {
941 |     public bool CreateConstructorReferences { get; private set; }
942 | 
943 |     public AspTypePropertyAttribute(bool createConstructorReferences)
944 |     {
945 |       CreateConstructorReferences = createConstructorReferences;
946 |     }
947 |   }
948 | 
949 |   [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
950 |   public sealed class RazorImportNamespaceAttribute : Attribute
951 |   {
952 |     public RazorImportNamespaceAttribute(string name)
953 |     {
954 |       Name = name;
955 |     }
956 | 
957 |     public string Name { get; private set; }
958 |   }
959 | 
960 |   [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
961 |   public sealed class RazorInjectionAttribute : Attribute
962 |   {
963 |     public RazorInjectionAttribute(string type, string fieldName)
964 |     {
965 |       Type = type;
966 |       FieldName = fieldName;
967 |     }
968 | 
969 |     public string Type { get; private set; }
970 |     public string FieldName { get; private set; }
971 |   }
972 | 
973 |   [AttributeUsage(AttributeTargets.Method)]
974 |   public sealed class RazorHelperCommonAttribute : Attribute { }
975 | 
976 |   [AttributeUsage(AttributeTargets.Property)]
977 |   public sealed class RazorLayoutAttribute : Attribute { }
978 | 
979 |   [AttributeUsage(AttributeTargets.Method)]
980 |   public sealed class RazorWriteLiteralMethodAttribute : Attribute { }
981 | 
982 |   [AttributeUsage(AttributeTargets.Method)]
983 |   public sealed class RazorWriteMethodAttribute : Attribute { }
984 | 
985 |   [AttributeUsage(AttributeTargets.Parameter)]
986 |   public sealed class RazorWriteMethodParameterAttribute : Attribute { }
987 | 
988 |   /// <summary>
989 |   /// Prevents the Member Reordering feature from tossing members of the marked class.
990 |   /// </summary>
991 |   /// <remarks>
992 |   /// The attribute must be mentioned in your member reordering patterns
993 |   /// </remarks>
994 |   [AttributeUsage(AttributeTargets.All)]
995 |   public sealed class NoReorder : Attribute { }
996 | }


--------------------------------------------------------------------------------