├── README.md
├── HrtzImageViewer
    ├── icon.ico
    ├── Graphics
    │   └── icon.ico
    ├── App.config
    ├── Properties
    │   ├── Settings.settings
    │   ├── Settings.Designer.cs
    │   ├── AssemblyInfo.cs
    │   ├── Resources.Designer.cs
    │   ├── Resources.resx
    │   └── Annotations.cs
    ├── Helpers
    │   ├── FileHelpers.cs
    │   └── BitmapImageCheck.cs
    ├── Converters
    │   ├── MaxHeightConverter.cs
    │   ├── MaxWidthConverter.cs
    │   └── BooleanToVisibilityConverter.cs
    ├── Extensions
    │   ├── ButtonIcon.cs
    │   ├── ObservableObject.cs
    │   └── RelayCommand.cs
    ├── ViewModels
    │   ├── CurrentImageVm.cs
    │   └── ShellVm.cs
    ├── Models
    │   └── CurrentImage.cs
    ├── App.xaml
    ├── Styles
    │   ├── Icons.xaml
    │   ├── WindowStyle.xaml
    │   └── ButtonStyle.xaml
    ├── MainWindow.xaml.cs
    ├── App.xaml.cs
    ├── MainWindow.xaml
    └── HrtzImageViewer.csproj
├── HrtzImageViewer.sln.DotSettings
├── HrtzImageViewer.sln
├── LICENSE
└── .gitignore


/README.md:
--------------------------------------------------------------------------------
1 | # HrtzImageViewer
2 | A very simple image viewer
3 | 


--------------------------------------------------------------------------------
/HrtzImageViewer/icon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Hertizch/HrtzImageViewer/master/HrtzImageViewer/icon.ico


--------------------------------------------------------------------------------
/HrtzImageViewer/Graphics/icon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Hertizch/HrtzImageViewer/master/HrtzImageViewer/Graphics/icon.ico


--------------------------------------------------------------------------------
/HrtzImageViewer/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>


--------------------------------------------------------------------------------
/HrtzImageViewer/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>


--------------------------------------------------------------------------------
/HrtzImageViewer/Helpers/FileHelpers.cs:
--------------------------------------------------------------------------------
 1 | namespace HrtzImageViewer.Helpers
 2 | {
 3 |     public static class FileHelpers
 4 |     {
 5 |         public static bool IsValidImage(string filename)
 6 |         {
 7 |             var bic = new BitmapImageCheck();
 8 |             return bic.IsExtensionSupported(filename);
 9 |         }
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/HrtzImageViewer.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/=HrtzImageViewer_002EAnnotations/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>


--------------------------------------------------------------------------------
/HrtzImageViewer/Converters/MaxHeightConverter.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Globalization;
 3 | using System.Windows;
 4 | using System.Windows.Data;
 5 | 
 6 | namespace HrtzImageViewer.Converters
 7 | {
 8 |     public class MaxHeightConverter : IValueConverter
 9 |     {
10 |         public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
11 |         {
12 |             return (int)value > SystemParameters.WorkArea.Height ? SystemParameters.WorkArea.Height : (int)value;
13 |         }
14 | 
15 |         public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
16 |         {
17 |             throw new NotImplementedException();
18 |         }
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/HrtzImageViewer/Converters/MaxWidthConverter.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Globalization;
 3 | using System.Windows;
 4 | using System.Windows.Data;
 5 | 
 6 | namespace HrtzImageViewer.Converters
 7 | {
 8 |     public class MaxWidthConverter : IValueConverter
 9 |     {
10 |         public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
11 |         {
12 |             return (int) value > SystemParameters.WorkArea.Width ? SystemParameters.WorkArea.Width : (int) value;
13 |         }
14 | 
15 |         public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
16 |         {
17 |             throw new NotImplementedException();
18 |         }
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/HrtzImageViewer/Extensions/ButtonIcon.cs:
--------------------------------------------------------------------------------
 1 | using System.Windows;
 2 | using System.Windows.Media;
 3 | 
 4 | namespace HrtzImageViewer.Extensions
 5 | {
 6 |     public class ButtonIcon
 7 |     {
 8 |         public static readonly DependencyProperty IconProperty =
 9 |             DependencyProperty.RegisterAttached("Icon", typeof (Geometry), typeof (ButtonIcon),
10 |                 new PropertyMetadata(default(Geometry)));
11 | 
12 |         public static void SetIcon(UIElement element, Geometry value)
13 |         {
14 |             element.SetValue(IconProperty, value);
15 |         }
16 | 
17 |         public static Geometry GetIcon(UIElement element)
18 |         {
19 |             return (Geometry)element.GetValue(IconProperty);
20 |         }
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/HrtzImageViewer/ViewModels/CurrentImageVm.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Windows;
 3 | using System.Windows.Media.Imaging;
 4 | using HrtzImageViewer.Extensions;
 5 | using HrtzImageViewer.Models;
 6 | 
 7 | namespace HrtzImageViewer.ViewModels
 8 | {
 9 |     public class CurrentImageVm : ObservableObject
10 |     {
11 |         public CurrentImageVm()
12 |         {
13 |             CurrentImage = new CurrentImage();
14 |         }
15 | 
16 |         public static CurrentImageVm Instance { get; set; } = new CurrentImageVm();
17 | 
18 |         private CurrentImage _currentImage;
19 | 
20 |         public CurrentImage CurrentImage
21 |         {
22 |             get { return _currentImage; }
23 |             set { SetField(ref _currentImage, value); }
24 |         }
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/HrtzImageViewer/Models/CurrentImage.cs:
--------------------------------------------------------------------------------
 1 | using System.Net.Mime;
 2 | using System.Windows.Media.Imaging;
 3 | using HrtzImageViewer.Extensions;
 4 | 
 5 | namespace HrtzImageViewer.Models
 6 | {
 7 |     public class CurrentImage : ObservableObject
 8 |     {
 9 |         private BitmapImage _bitmapImage;
10 |         private bool _loadError;
11 |         private string _errorMessage;
12 | 
13 |         public BitmapImage BitmapImage
14 |         {
15 |             get { return _bitmapImage; }
16 |             set { SetField(ref _bitmapImage, value); }
17 |         }
18 | 
19 |         public bool LoadError
20 |         {
21 |             get { return _loadError; }
22 |             set { SetField(ref _loadError, value); }
23 |         }
24 | 
25 |         public string ErrorMessage
26 |         {
27 |             get { return _errorMessage; }
28 |             set { SetField(ref _errorMessage, value); }
29 |         }
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/HrtzImageViewer/App.xaml:
--------------------------------------------------------------------------------
 1 | <Application x:Class="HrtzImageViewer.App"
 2 |              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 3 |              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 4 |              xmlns:viewModels="clr-namespace:HrtzImageViewer.ViewModels"
 5 |              Startup="App_Startup">
 6 |     <Application.Resources>
 7 |         <ResourceDictionary>
 8 |             <ResourceDictionary.MergedDictionaries>
 9 |                 <ResourceDictionary Source="Styles/WindowStyle.xaml" />
10 |                 <ResourceDictionary Source="Styles/ButtonStyle.xaml" />
11 |                 <ResourceDictionary Source="Styles/Icons.xaml" />
12 |             </ResourceDictionary.MergedDictionaries>
13 |             <viewModels:ShellVm x:Key="ShellVm" />
14 |             <viewModels:CurrentImageVm x:Key="CurrentImageVm" />
15 |         </ResourceDictionary>
16 |     </Application.Resources>
17 | </Application>
18 | 


--------------------------------------------------------------------------------
/HrtzImageViewer/Extensions/ObservableObject.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using System.ComponentModel;
 3 | using System.Runtime.CompilerServices;
 4 | using HrtzImageViewer.Annotations;
 5 | 
 6 | namespace HrtzImageViewer.Extensions
 7 | {
 8 |     public class ObservableObject : INotifyPropertyChanged
 9 |     {
10 |         public event PropertyChangedEventHandler PropertyChanged;
11 | 
12 |         [NotifyPropertyChangedInvocator]
13 |         protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
14 |         {
15 |             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
16 |         }
17 | 
18 |         protected bool SetField<T>(ref T field, T value, [CallerMemberName] string propertyName = null)
19 |         {
20 |             if (EqualityComparer<T>.Default.Equals(field, value)) return false;
21 |             field = value;
22 |             OnPropertyChanged(propertyName);
23 |             return true;
24 |         }
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/HrtzImageViewer/Extensions/RelayCommand.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Windows.Input;
 3 | 
 4 | namespace HrtzImageViewer.Extensions
 5 | {
 6 |     public class RelayCommand : ICommand
 7 |     {
 8 |         private readonly Action<object> _execute;
 9 |         private readonly Func<object, bool> _canExecute;
10 | 
11 |         public event EventHandler CanExecuteChanged
12 |         {
13 |             add { CommandManager.RequerySuggested += value; }
14 |             remove { CommandManager.RequerySuggested -= value; }
15 |         }
16 | 
17 |         public RelayCommand(Action<object> execute, Func<object, bool> canExecute = null)
18 |         {
19 |             _execute = execute;
20 |             _canExecute = canExecute;
21 |         }
22 | 
23 |         public bool CanExecute(object parameter)
24 |         {
25 |             return _canExecute == null || _canExecute(parameter);
26 |         }
27 | 
28 |         public void Execute(object parameter)
29 |         {
30 |             _execute(parameter);
31 |         }
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/HrtzImageViewer/Styles/Icons.xaml:
--------------------------------------------------------------------------------
1 | <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
2 |                     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
3 | 
4 |     <Geometry x:Key="IconClose">M810.667 170.667q18.333 0 30.5 12.167t12.167 30.5q0 18-12.333 30.333l-268.667 268.333 268.667 268.333q12.333 12.333 12.333 30.333 0 18.333-12.167 30.5t-30.5 12.167q-18 0-30.333-12.333l-268.333-268.667-268.333 268.667q-12.333 12.333-30.333 12.333-18.333 0-30.5-12.167t-12.167-30.5q0-18 12.333-30.333l268.667-268.333-268.667-268.333q-12.333-12.333-12.333-30.333 0-18.333 12.167-30.5t30.5-12.167q18 0 30.333 12.333l268.333 268.667 268.333-268.667q12.333-12.333 30.333-12.333z</Geometry>
5 |     <Geometry x:Key="IconOpenAs">M14.016 3h6.984v6.984h-2.016v-3.563l-9.797 9.797-1.406-1.406 9.797-9.797h-3.563v-2.016zM18.984 18.984v-6.984h2.016v6.984c0 1.078-0.938 2.016-2.016 2.016h-13.969c-1.125 0-2.016-0.938-2.016-2.016v-13.969c0-1.078 0.891-2.016 2.016-2.016h6.984v2.016h-6.984v13.969h13.969z</Geometry>
6 | 
7 | </ResourceDictionary>


--------------------------------------------------------------------------------
/HrtzImageViewer.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio 14
 4 | VisualStudioVersion = 14.0.25123.0
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HrtzImageViewer", "HrtzImageViewer\HrtzImageViewer.csproj", "{23469200-B289-48DC-B0AD-1AA8444C795C}"
 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 | 		{23469200-B289-48DC-B0AD-1AA8444C795C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
15 | 		{23469200-B289-48DC-B0AD-1AA8444C795C}.Debug|Any CPU.Build.0 = Debug|Any CPU
16 | 		{23469200-B289-48DC-B0AD-1AA8444C795C}.Release|Any CPU.ActiveCfg = Release|Any CPU
17 | 		{23469200-B289-48DC-B0AD-1AA8444C795C}.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) 2016 
 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 | 


--------------------------------------------------------------------------------
/HrtzImageViewer/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 HrtzImageViewer.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 | 


--------------------------------------------------------------------------------
/HrtzImageViewer/Styles/WindowStyle.xaml:
--------------------------------------------------------------------------------
 1 | <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 2 |                     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
 3 | 
 4 |     <Style x:Key="StyleMainWindow" TargetType="{x:Type Window}">
 5 |         <Setter Property="OverridesDefaultStyle" Value="True" />
 6 |         <Setter Property="UseLayoutRounding" Value="True" />
 7 |         <Setter Property="WindowStyle" Value="None" />
 8 |         <Setter Property="BorderThickness" Value="0" />
 9 |         <Setter Property="Background" Value="Black" />
10 |         <Setter Property="ResizeMode" Value="NoResize" />
11 |         <Setter Property="Icon" Value="../Graphics/icon.ico" />
12 |         <Setter Property="Template">
13 |             <Setter.Value>
14 |                 <ControlTemplate TargetType="{x:Type Window}">
15 |                     <Border BorderThickness="{TemplateBinding BorderThickness}" BorderBrush="{TemplateBinding BorderBrush}" Background="{TemplateBinding Background}">
16 |                         <Grid>
17 |                             <ContentPresenter />
18 |                         </Grid>
19 |                     </Border>
20 |                 </ControlTemplate>
21 |             </Setter.Value>
22 |         </Setter>
23 |     </Style>
24 | 
25 | </ResourceDictionary>


--------------------------------------------------------------------------------
/HrtzImageViewer/ViewModels/ShellVm.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Diagnostics;
 3 | using System.IO;
 4 | using System.Windows;
 5 | using HrtzImageViewer.Extensions;
 6 | 
 7 | namespace HrtzImageViewer.ViewModels
 8 | {
 9 |     public class ShellVm : ObservableObject
10 |     {
11 |         public ShellVm()
12 |         { }
13 | 
14 |         private RelayCommand _cmdCloseApp;
15 |         private RelayCommand _cmdOpenAsDialog;
16 | 
17 |         public RelayCommand CmdCloseApp
18 |         {
19 |             get
20 |             {
21 |                 return _cmdCloseApp ??
22 |                        (_cmdCloseApp = new RelayCommand(ExecuteCmd_CloseApp, p => true));
23 |             }
24 |         }
25 | 
26 |         public RelayCommand CmdOpenAsDialog
27 |         {
28 |             get
29 |             {
30 |                 return _cmdOpenAsDialog ??
31 |                        (_cmdOpenAsDialog = new RelayCommand(p => ExecuteCmd_OpenAsDialog(p as Uri), p => p != null));
32 |             }
33 |         }
34 | 
35 |         private static void ExecuteCmd_CloseApp(object obj)
36 |         {
37 |             Application.Current?.MainWindow?.Close();
38 |         }
39 | 
40 |         public static void ExecuteCmd_OpenAsDialog(Uri sourceUri)
41 |         {
42 |             var sourcePath = sourceUri.AbsolutePath.Replace('/', Path.DirectorySeparatorChar);
43 |             var args = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.System), "shell32.dll");
44 |             args += ",OpenAs_RunDLL " + sourcePath;
45 | 
46 |             try
47 |             {
48 |                 Process.Start("rundll32.exe", args);
49 |             }
50 |             catch (Exception ex)
51 |             {
52 |                 Console.WriteLine(ex);
53 |             }
54 |         }
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/HrtzImageViewer/MainWindow.xaml.cs:
--------------------------------------------------------------------------------
 1 | using System.Windows;
 2 | using System.Windows.Input;
 3 | 
 4 | namespace HrtzImageViewer
 5 | {
 6 |     /// <summary>
 7 |     /// Interaction logic for MainWindow.xaml
 8 |     /// </summary>
 9 |     public partial class MainWindow : Window
10 |     {
11 |         public MainWindow()
12 |         {
13 |             InitializeComponent();
14 |             /*
15 |             BitmapImageCheck bic = new BitmapImageCheck();
16 |             MessageBox.Show(bic.ToString());
17 |             */
18 |         }
19 | 
20 |         // this is the offset of the mouse cursor from the top left corner of the window
21 |         private Point _offset;
22 | 
23 |         private void MainWindow_OnMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
24 |         {
25 |             // capturing the mouse here will redirect all events to this window, even if
26 |             // the mouse cursor should leave the window area
27 |             Mouse.Capture(this, CaptureMode.Element);
28 | 
29 |             var cursorPos = PointToScreen(Mouse.GetPosition(this));
30 |             var windowPos = new Point(Left, Top);
31 |             _offset = (Point)(cursorPos - windowPos);
32 |         }
33 | 
34 |         private void MainWindow_OnMouseLeftButtonUp(object sender, MouseButtonEventArgs e)
35 |         {
36 |             Mouse.Capture(null);
37 |         }
38 | 
39 |         private void MainWindow_OnMouseMove(object sender, MouseEventArgs e)
40 |         {
41 |             if (!Equals(Mouse.Captured, this) || Mouse.LeftButton != MouseButtonState.Pressed) return;
42 | 
43 |             var cursorPos = PointToScreen(Mouse.GetPosition(this));
44 |             var newLeft = cursorPos.X - _offset.X;
45 |             var newTop = cursorPos.Y - _offset.Y;
46 |             Left = newLeft;
47 |             Top = newTop;
48 |         }
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/HrtzImageViewer/Converters/BooleanToVisibilityConverter.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Globalization;
 3 | using System.Windows;
 4 | using System.Windows.Data;
 5 | 
 6 | namespace HrtzImageViewer.Converters
 7 | {
 8 |     /// <summary>
 9 |     /// Converts Boolean Values to Control.Visibility values
10 |     /// </summary>
11 |     public class BooleanToVisibilityConverter : IValueConverter
12 |     {
13 |         //Set to true if you want to show control when boolean value is true
14 |         //Set to false if you want to hide/collapse control when value is true
15 |         public bool TriggerValue { get; set; }
16 | 
17 |         //Set to true if you just want to hide the control
18 |         //else set to false if you want to collapse the control
19 |         public bool IsHidden { get; set; }
20 | 
21 |         private object GetVisibility(object value)
22 |         {
23 |             if (!(value is bool))
24 |                 return DependencyProperty.UnsetValue;
25 | 
26 |             var objValue = (bool)value;
27 | 
28 |             if ((objValue && TriggerValue && IsHidden) || (!objValue && !TriggerValue && IsHidden))
29 |             {
30 |                 return Visibility.Hidden;
31 |             }
32 | 
33 |             if ((objValue && TriggerValue && !IsHidden) || (!objValue && !TriggerValue && !IsHidden))
34 |             {
35 |                 return Visibility.Collapsed;
36 |             }
37 | 
38 |             return Visibility.Visible;
39 |         }
40 | 
41 |         public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
42 |         {
43 |             return GetVisibility(value);
44 |         }
45 | 
46 |         public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
47 |         {
48 |             throw new NotImplementedException();
49 |         }
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/HrtzImageViewer/App.xaml.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Diagnostics;
 3 | using System.Windows;
 4 | using System.Windows.Media.Imaging;
 5 | using HrtzImageViewer.Helpers;
 6 | using HrtzImageViewer.ViewModels;
 7 | 
 8 | namespace HrtzImageViewer
 9 | {
10 |     /// <summary>
11 |     /// Interaction logic for App.xaml
12 |     /// </summary>
13 |     public partial class App
14 |     {
15 |         void App_Startup(object sender, StartupEventArgs e)
16 |         {
17 |             if (e != null && e.Args.Length > 0)
18 |             {
19 |                 var imageSource = e.Args[0];
20 | 
21 |                 if (!string.IsNullOrEmpty(imageSource))
22 |                 {
23 |                     if (FileHelpers.IsValidImage(imageSource))
24 |                     {
25 |                         CurrentImageVm.Instance.CurrentImage.BitmapImage = new BitmapImage(new Uri(imageSource));
26 |                     }
27 |                     else
28 |                     {
29 |                         Debug.WriteLine("Not a valid image file");
30 |                         CurrentImageVm.Instance.CurrentImage.LoadError = true;
31 |                         CurrentImageVm.Instance.CurrentImage.ErrorMessage = "Not a valid image file";
32 |                     }
33 |                 }
34 |                 else
35 |                 {
36 |                     Debug.WriteLine("No startup arguments provided");
37 |                     CurrentImageVm.Instance.CurrentImage.LoadError = true;
38 |                     CurrentImageVm.Instance.CurrentImage.ErrorMessage = "No startup arguments provided";
39 |                 }
40 |             }
41 |             else
42 |             {
43 |                 Debug.WriteLine("No startup arguments provided");
44 |                 CurrentImageVm.Instance.CurrentImage.LoadError = true;
45 |                 CurrentImageVm.Instance.CurrentImage.ErrorMessage = "No startup arguments provided";
46 |             }
47 | 
48 |             var mainWindow = new MainWindow();
49 |             mainWindow.Show();
50 |         }
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/HrtzImageViewer/Styles/ButtonStyle.xaml:
--------------------------------------------------------------------------------
 1 | <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 2 |                     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 3 |                     xmlns:ext="clr-namespace:HrtzImageViewer.Extensions">
 4 | 
 5 |     <Style x:Key="StyleTitlebarButton" TargetType="{x:Type Button}">
 6 |         <Setter Property="OverridesDefaultStyle" Value="True" />
 7 |         <Setter Property="UseLayoutRounding" Value="True" />
 8 |         <Setter Property="Width" Value="35" />
 9 |         <Setter Property="Height" Value="35" />
10 |         <Setter Property="Background" Value="Transparent" />
11 |         <Setter Property="Foreground" Value="Transparent" />
12 |         <Setter Property="Template">
13 |             <Setter.Value>
14 |                 <ControlTemplate TargetType="{x:Type Button}">
15 |                     <Border Background="{TemplateBinding Background}" Width="{TemplateBinding Width}" Height="{TemplateBinding Height}">
16 |                         <Viewbox Width="10">
17 |                             <Path x:Name="PathRoot" Data="{TemplateBinding ext:ButtonIcon.Icon}" Fill="{TemplateBinding Foreground}" Stretch="Uniform" />
18 |                         </Viewbox>
19 |                     </Border>
20 |                     <ControlTemplate.Triggers>
21 |                         <Trigger Property="IsMouseOver" Value="True">
22 |                             <Setter Property="Foreground" Value="#FFDADADA" />
23 |                             <Setter Property="Background" Value="#7F000000" />
24 |                         </Trigger>
25 |                         <Trigger Property="IsPressed" Value="True">
26 |                             <Setter Property="Foreground" Value="White" />
27 |                             <Setter Property="Background" Value="#FF0057AA" />
28 |                         </Trigger>
29 |                     </ControlTemplate.Triggers>
30 |                 </ControlTemplate>
31 |             </Setter.Value>
32 |         </Setter>
33 |     </Style>
34 | 
35 | </ResourceDictionary>


--------------------------------------------------------------------------------
/HrtzImageViewer/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("HrtzImageViewer")]
11 | [assembly: AssemblyDescription("HrtzImageViewer")]
12 | [assembly: AssemblyConfiguration("")]
13 | [assembly: AssemblyCompany("Hertizch")]
14 | [assembly: AssemblyProduct("HrtzImageViewer")]
15 | [assembly: AssemblyCopyright("MIT")]
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 | 


--------------------------------------------------------------------------------
/HrtzImageViewer/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 HrtzImageViewer.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("HrtzImageViewer.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 | 


--------------------------------------------------------------------------------
/HrtzImageViewer/MainWindow.xaml:
--------------------------------------------------------------------------------
 1 | <Window x:Class="HrtzImageViewer.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:ext="clr-namespace:HrtzImageViewer.Extensions"
 7 |         xmlns:converters="clr-namespace:HrtzImageViewer.Converters"
 8 |         mc:Ignorable="d"
 9 |         Title="HrtzImageViewer"
10 |         WindowStartupLocation="CenterScreen"
11 |         MouseLeftButtonDown="MainWindow_OnMouseLeftButtonDown"
12 |         MouseLeftButtonUp="MainWindow_OnMouseLeftButtonUp"
13 |         MouseMove="MainWindow_OnMouseMove"
14 |         Style="{StaticResource StyleMainWindow}"
15 |         Height="{Binding Path=Instance.CurrentImage.BitmapImage.PixelHeight, FallbackValue=200}"
16 |         Width="{Binding Path=Instance.CurrentImage.BitmapImage.PixelWidth, FallbackValue=400}"
17 |         DataContext="{StaticResource CurrentImageVm}">
18 |     
19 |     <Window.Resources>
20 |         <converters:BooleanToVisibilityConverter x:Key="BooleanToVisibilityConverter" TriggerValue="False" IsHidden="False" />
21 |         <converters:MaxWidthConverter x:Key="MaxWidthConverter" />
22 |         <converters:MaxHeightConverter x:Key="MaxHeightConverter" />
23 |     </Window.Resources>
24 |     
25 |     <Window.MaxWidth>
26 |         <Binding Path="Instance.CurrentImage.BitmapImage.PixelWidth" Converter="{StaticResource MaxWidthConverter}" />
27 |     </Window.MaxWidth>
28 |     
29 |     <Window.MaxHeight>
30 |         <Binding Path="Instance.CurrentImage.BitmapImage.PixelHeight" Converter="{StaticResource MaxHeightConverter}" />
31 |     </Window.MaxHeight>
32 | 
33 |     <Window.Background>
34 |         <ImageBrush x:Name="ImageBrushRoot" ImageSource="{Binding Path=Instance.CurrentImage.BitmapImage.UriSource}" Stretch="Uniform" />
35 |     </Window.Background>
36 | 
37 |     <Grid>
38 |         <Grid.RowDefinitions>
39 |             <RowDefinition Height="Auto" />
40 |             <RowDefinition Height="*" />
41 |         </Grid.RowDefinitions>
42 | 
43 |         <StackPanel Orientation="Horizontal" VerticalAlignment="Top" HorizontalAlignment="Right" DataContext="{StaticResource ShellVm}">
44 |             <Button Style="{StaticResource StyleTitlebarButton}" ext:ButtonIcon.Icon="{StaticResource IconOpenAs}" Command="{Binding Path=CmdOpenAsDialog}" CommandParameter="{Binding Source={StaticResource CurrentImageVm}, Path=Instance.CurrentImage.BitmapImage.UriSource}" ToolTip="Open as..." />
45 |             <Button Style="{StaticResource StyleTitlebarButton}" ext:ButtonIcon.Icon="{StaticResource IconClose}" Command="{Binding Path=CmdCloseApp}" />
46 |         </StackPanel>
47 | 
48 |         <!-- {Binding Path=Instance.CurrentImage.LoadError, Converter={StaticResource BooleanToVisibilityConverter}} -->
49 |         <Grid Grid.Row="1" Margin="0,-30,0,0" VerticalAlignment="Center" Visibility="{Binding Path=Instance.CurrentImage.LoadError, Converter={StaticResource BooleanToVisibilityConverter}}">
50 |             <StackPanel>
51 |                 <TextBlock Text="oops..." Foreground="#FFC33500" FontSize="36" HorizontalAlignment="Center" />
52 |                 <TextBlock Text="{Binding Path=Instance.CurrentImage.ErrorMessage, FallbackValue=No more info}" Foreground="White" TextWrapping="Wrap" HorizontalAlignment="Center" />
53 |             </StackPanel>
54 |         </Grid>
55 |     </Grid>
56 | </Window>
57 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | ## Ignore Visual Studio temporary files, build results, and
  2 | ## files generated by popular Visual Studio add-ons.
  3 | 
  4 | # User-specific files
  5 | *.suo
  6 | *.user
  7 | *.userosscache
  8 | *.sln.docstates
  9 | 
 10 | # User-specific files (MonoDevelop/Xamarin Studio)
 11 | *.userprefs
 12 | 
 13 | # Build results
 14 | [Dd]ebug/
 15 | [Dd]ebugPublic/
 16 | [Rr]elease/
 17 | [Rr]eleases/
 18 | x64/
 19 | x86/
 20 | bld/
 21 | [Bb]in/
 22 | [Oo]bj/
 23 | [Ll]og/
 24 | 
 25 | # Visual Studio 2015 cache/options directory
 26 | .vs/
 27 | # Uncomment if you have tasks that create the project's static files in wwwroot
 28 | #wwwroot/
 29 | 
 30 | # MSTest test Results
 31 | [Tt]est[Rr]esult*/
 32 | [Bb]uild[Ll]og.*
 33 | 
 34 | # NUNIT
 35 | *.VisualState.xml
 36 | TestResult.xml
 37 | 
 38 | # Build Results of an ATL Project
 39 | [Dd]ebugPS/
 40 | [Rr]eleasePS/
 41 | dlldata.c
 42 | 
 43 | # DNX
 44 | project.lock.json
 45 | artifacts/
 46 | 
 47 | *_i.c
 48 | *_p.c
 49 | *_i.h
 50 | *.ilk
 51 | *.meta
 52 | *.obj
 53 | *.pch
 54 | *.pdb
 55 | *.pgc
 56 | *.pgd
 57 | *.rsp
 58 | *.sbr
 59 | *.tlb
 60 | *.tli
 61 | *.tlh
 62 | *.tmp
 63 | *.tmp_proj
 64 | *.log
 65 | *.vspscc
 66 | *.vssscc
 67 | .builds
 68 | *.pidb
 69 | *.svclog
 70 | *.scc
 71 | 
 72 | # Chutzpah Test files
 73 | _Chutzpah*
 74 | 
 75 | # Visual C++ cache files
 76 | ipch/
 77 | *.aps
 78 | *.ncb
 79 | *.opendb
 80 | *.opensdf
 81 | *.sdf
 82 | *.cachefile
 83 | *.VC.db
 84 | *.VC.VC.opendb
 85 | 
 86 | # Visual Studio profiler
 87 | *.psess
 88 | *.vsp
 89 | *.vspx
 90 | *.sap
 91 | 
 92 | # TFS 2012 Local Workspace
 93 | $tf/
 94 | 
 95 | # Guidance Automation Toolkit
 96 | *.gpState
 97 | 
 98 | # ReSharper is a .NET coding add-in
 99 | _ReSharper*/
100 | *.[Rr]e[Ss]harper
101 | *.DotSettings.user
102 | 
103 | # JustCode is a .NET coding add-in
104 | .JustCode
105 | 
106 | # TeamCity is a build add-in
107 | _TeamCity*
108 | 
109 | # DotCover is a Code Coverage Tool
110 | *.dotCover
111 | 
112 | # NCrunch
113 | _NCrunch_*
114 | .*crunch*.local.xml
115 | nCrunchTemp_*
116 | 
117 | # MightyMoose
118 | *.mm.*
119 | AutoTest.Net/
120 | 
121 | # Web workbench (sass)
122 | .sass-cache/
123 | 
124 | # Installshield output folder
125 | [Ee]xpress/
126 | 
127 | # DocProject is a documentation generator add-in
128 | DocProject/buildhelp/
129 | DocProject/Help/*.HxT
130 | DocProject/Help/*.HxC
131 | DocProject/Help/*.hhc
132 | DocProject/Help/*.hhk
133 | DocProject/Help/*.hhp
134 | DocProject/Help/Html2
135 | DocProject/Help/html
136 | 
137 | # Click-Once directory
138 | publish/
139 | 
140 | # Publish Web Output
141 | *.[Pp]ublish.xml
142 | *.azurePubxml
143 | # TODO: Comment the next line if you want to checkin your web deploy settings
144 | # but database connection strings (with potential passwords) will be unencrypted
145 | *.pubxml
146 | *.publishproj
147 | 
148 | # Microsoft Azure Web App publish settings. Comment the next line if you want to
149 | # checkin your Azure Web App publish settings, but sensitive information contained
150 | # in these scripts will be unencrypted
151 | PublishScripts/
152 | 
153 | # NuGet Packages
154 | *.nupkg
155 | # The packages folder can be ignored because of Package Restore
156 | **/packages/*
157 | # except build/, which is used as an MSBuild target.
158 | !**/packages/build/
159 | # Uncomment if necessary however generally it will be regenerated when needed
160 | #!**/packages/repositories.config
161 | # NuGet v3's project.json files produces more ignoreable files
162 | *.nuget.props
163 | *.nuget.targets
164 | 
165 | # Microsoft Azure Build Output
166 | csx/
167 | *.build.csdef
168 | 
169 | # Microsoft Azure Emulator
170 | ecf/
171 | rcf/
172 | 
173 | # Windows Store app package directories and files
174 | AppPackages/
175 | BundleArtifacts/
176 | Package.StoreAssociation.xml
177 | _pkginfo.txt
178 | 
179 | # Visual Studio cache files
180 | # files ending in .cache can be ignored
181 | *.[Cc]ache
182 | # but keep track of directories ending in .cache
183 | !*.[Cc]ache/
184 | 
185 | # Others
186 | ClientBin/
187 | ~$*
188 | *~
189 | *.dbmdl
190 | *.dbproj.schemaview
191 | *.pfx
192 | *.publishsettings
193 | node_modules/
194 | orleans.codegen.cs
195 | 
196 | # Since there are multiple workflows, uncomment next line to ignore bower_components
197 | # (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
198 | #bower_components/
199 | 
200 | # RIA/Silverlight projects
201 | Generated_Code/
202 | 
203 | # Backup & report files from converting an old project file
204 | # to a newer Visual Studio version. Backup files are not needed,
205 | # because we have git ;-)
206 | _UpgradeReport_Files/
207 | Backup*/
208 | UpgradeLog*.XML
209 | UpgradeLog*.htm
210 | 
211 | # SQL Server files
212 | *.mdf
213 | *.ldf
214 | 
215 | # Business Intelligence projects
216 | *.rdl.data
217 | *.bim.layout
218 | *.bim_*.settings
219 | 
220 | # Microsoft Fakes
221 | FakesAssemblies/
222 | 
223 | # GhostDoc plugin setting file
224 | *.GhostDoc.xml
225 | 
226 | # Node.js Tools for Visual Studio
227 | .ntvs_analysis.dat
228 | 
229 | # Visual Studio 6 build log
230 | *.plg
231 | 
232 | # Visual Studio 6 workspace options file
233 | *.opt
234 | 
235 | # Visual Studio LightSwitch build output
236 | **/*.HTMLClient/GeneratedArtifacts
237 | **/*.DesktopClient/GeneratedArtifacts
238 | **/*.DesktopClient/ModelManifest.xml
239 | **/*.Server/GeneratedArtifacts
240 | **/*.Server/ModelManifest.xml
241 | _Pvt_Extensions
242 | 
243 | # Paket dependency manager
244 | .paket/paket.exe
245 | paket-files/
246 | 
247 | # FAKE - F# Make
248 | .fake/
249 | 
250 | # JetBrains Rider
251 | .idea/
252 | *.sln.iml
253 | 


--------------------------------------------------------------------------------
/HrtzImageViewer/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>


--------------------------------------------------------------------------------
/HrtzImageViewer/HrtzImageViewer.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>{23469200-B289-48DC-B0AD-1AA8444C795C}</ProjectGuid>
  8 |     <OutputType>WinExe</OutputType>
  9 |     <AppDesignerFolder>Properties</AppDesignerFolder>
 10 |     <RootNamespace>HrtzImageViewer</RootNamespace>
 11 |     <AssemblyName>HrtzImageViewer</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 |   </PropertyGroup>
 18 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
 19 |     <PlatformTarget>AnyCPU</PlatformTarget>
 20 |     <DebugSymbols>true</DebugSymbols>
 21 |     <DebugType>full</DebugType>
 22 |     <Optimize>false</Optimize>
 23 |     <OutputPath>bin\Debug\</OutputPath>
 24 |     <DefineConstants>DEBUG;TRACE</DefineConstants>
 25 |     <ErrorReport>prompt</ErrorReport>
 26 |     <WarningLevel>4</WarningLevel>
 27 |   </PropertyGroup>
 28 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
 29 |     <PlatformTarget>AnyCPU</PlatformTarget>
 30 |     <DebugType>pdbonly</DebugType>
 31 |     <Optimize>true</Optimize>
 32 |     <OutputPath>bin\Release\</OutputPath>
 33 |     <DefineConstants>TRACE</DefineConstants>
 34 |     <ErrorReport>prompt</ErrorReport>
 35 |     <WarningLevel>4</WarningLevel>
 36 |   </PropertyGroup>
 37 |   <PropertyGroup>
 38 |     <ApplicationIcon>icon.ico</ApplicationIcon>
 39 |   </PropertyGroup>
 40 |   <ItemGroup>
 41 |     <Reference Include="System" />
 42 |     <Reference Include="System.Data" />
 43 |     <Reference Include="System.Xml" />
 44 |     <Reference Include="Microsoft.CSharp" />
 45 |     <Reference Include="System.Core" />
 46 |     <Reference Include="System.Xml.Linq" />
 47 |     <Reference Include="System.Data.DataSetExtensions" />
 48 |     <Reference Include="System.Net.Http" />
 49 |     <Reference Include="System.Xaml">
 50 |       <RequiredTargetFramework>4.0</RequiredTargetFramework>
 51 |     </Reference>
 52 |     <Reference Include="WindowsBase" />
 53 |     <Reference Include="PresentationCore" />
 54 |     <Reference Include="PresentationFramework" />
 55 |   </ItemGroup>
 56 |   <ItemGroup>
 57 |     <ApplicationDefinition Include="App.xaml">
 58 |       <Generator>MSBuild:Compile</Generator>
 59 |       <SubType>Designer</SubType>
 60 |     </ApplicationDefinition>
 61 |     <Compile Include="Converters\BooleanToVisibilityConverter.cs" />
 62 |     <Compile Include="Converters\MaxHeightConverter.cs" />
 63 |     <Compile Include="Converters\MaxWidthConverter.cs" />
 64 |     <Compile Include="Extensions\ButtonIcon.cs" />
 65 |     <Compile Include="Extensions\ObservableObject.cs" />
 66 |     <Compile Include="Extensions\RelayCommand.cs" />
 67 |     <Compile Include="Helpers\BitmapImageCheck.cs" />
 68 |     <Compile Include="Helpers\FileHelpers.cs" />
 69 |     <Compile Include="Models\CurrentImage.cs" />
 70 |     <Compile Include="Properties\Annotations.cs" />
 71 |     <Compile Include="ViewModels\CurrentImageVm.cs" />
 72 |     <Compile Include="ViewModels\ShellVm.cs" />
 73 |     <Page Include="MainWindow.xaml">
 74 |       <Generator>MSBuild:Compile</Generator>
 75 |       <SubType>Designer</SubType>
 76 |     </Page>
 77 |     <Compile Include="App.xaml.cs">
 78 |       <DependentUpon>App.xaml</DependentUpon>
 79 |       <SubType>Code</SubType>
 80 |     </Compile>
 81 |     <Compile Include="MainWindow.xaml.cs">
 82 |       <DependentUpon>MainWindow.xaml</DependentUpon>
 83 |       <SubType>Code</SubType>
 84 |     </Compile>
 85 |     <Page Include="Styles\ButtonStyle.xaml">
 86 |       <SubType>Designer</SubType>
 87 |       <Generator>MSBuild:Compile</Generator>
 88 |     </Page>
 89 |     <Page Include="Styles\Icons.xaml">
 90 |       <SubType>Designer</SubType>
 91 |       <Generator>MSBuild:Compile</Generator>
 92 |     </Page>
 93 |     <Page Include="Styles\WindowStyle.xaml">
 94 |       <SubType>Designer</SubType>
 95 |       <Generator>MSBuild:Compile</Generator>
 96 |     </Page>
 97 |   </ItemGroup>
 98 |   <ItemGroup>
 99 |     <Compile Include="Properties\AssemblyInfo.cs">
100 |       <SubType>Code</SubType>
101 |     </Compile>
102 |     <Compile Include="Properties\Resources.Designer.cs">
103 |       <AutoGen>True</AutoGen>
104 |       <DesignTime>True</DesignTime>
105 |       <DependentUpon>Resources.resx</DependentUpon>
106 |     </Compile>
107 |     <Compile Include="Properties\Settings.Designer.cs">
108 |       <AutoGen>True</AutoGen>
109 |       <DependentUpon>Settings.settings</DependentUpon>
110 |       <DesignTimeSharedInput>True</DesignTimeSharedInput>
111 |     </Compile>
112 |     <EmbeddedResource Include="Properties\Resources.resx">
113 |       <Generator>ResXFileCodeGenerator</Generator>
114 |       <LastGenOutput>Resources.Designer.cs</LastGenOutput>
115 |     </EmbeddedResource>
116 |     <None Include="Properties\Settings.settings">
117 |       <Generator>SettingsSingleFileGenerator</Generator>
118 |       <LastGenOutput>Settings.Designer.cs</LastGenOutput>
119 |     </None>
120 |     <AppDesigner Include="Properties\" />
121 |   </ItemGroup>
122 |   <ItemGroup>
123 |     <None Include="App.config" />
124 |   </ItemGroup>
125 |   <ItemGroup>
126 |     <Resource Include="Graphics\icon.ico" />
127 |   </ItemGroup>
128 |   <ItemGroup>
129 |     <Resource Include="icon.ico" />
130 |   </ItemGroup>
131 |   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
132 |   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
133 |        Other similar extension points exist, see Microsoft.Common.targets.
134 |   <Target Name="BeforeBuild">
135 |   </Target>
136 |   <Target Name="AfterBuild">
137 |   </Target>
138 |   -->
139 | </Project>


--------------------------------------------------------------------------------
/HrtzImageViewer/Helpers/BitmapImageCheck.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Linq;
  4 | using Microsoft.Win32;
  5 | 
  6 | namespace HrtzImageViewer.Helpers
  7 | {
  8 |     /// <summary>
  9 |     /// Provides methods for checking whether a file can likely be opened as a BitmapImage, based upon its file extension
 10 |     /// </summary>
 11 |     public class BitmapImageCheck : IDisposable
 12 |     {
 13 |         #region class variables
 14 | 
 15 |         readonly RegistryKey _baseKey;
 16 |         private const string WicDecoderCategory = "{7ED96837-96F0-4812-B211-F13C24117ED3}";
 17 | 
 18 |         #endregion
 19 | 
 20 |         #region constructors
 21 | 
 22 |         public BitmapImageCheck()
 23 |         {
 24 |             string baseKeyPath;
 25 | 
 26 |             if (Environment.Is64BitOperatingSystem && !Environment.Is64BitProcess)
 27 |                 baseKeyPath = "Wow6432Node\\CLSID";
 28 |             else
 29 |                 baseKeyPath = "CLSID";
 30 | 
 31 |             _baseKey = Registry.ClassesRoot.OpenSubKey(baseKeyPath, false);
 32 | 
 33 |             RecalculateExtensions();
 34 |         }
 35 | 
 36 |         #endregion
 37 | 
 38 |         #region properties
 39 | 
 40 |         /// <summary>
 41 |         /// File extensions that are supported by decoders found elsewhere on the system
 42 |         /// </summary>
 43 |         public string[] CustomSupportedExtensions { get; private set; }
 44 | 
 45 |         /// <summary>
 46 |         /// File extensions that are supported natively by .NET
 47 |         /// </summary>
 48 |         public string[] NativeSupportedExtensions { get; private set; }
 49 | 
 50 |         /// <summary>
 51 |         /// File extensions that are supported both natively by NET, and by decoders found elsewhere on the system
 52 |         /// </summary>
 53 |         public string[] AllSupportedExtensions { get; private set; }
 54 | 
 55 |         #endregion
 56 | 
 57 |         #region public methods
 58 | 
 59 |         /// <summary>
 60 |         /// Check whether a file is likely to be supported by BitmapImage based upon its extension
 61 |         /// </summary>
 62 |         /// <param name="extension">File extension (with or without leading full stop), file name or file path</param>
 63 |         /// <returns>True if extension appears to contain a supported file extension, false if no suitable extension was found</returns>
 64 |         public bool IsExtensionSupported(string extension)
 65 |         {
 66 |             //prepare extension, should a full path be given
 67 |             if (extension.Contains("."))
 68 |                 extension = extension.Substring(extension.LastIndexOf('.') + 1);
 69 | 
 70 |             extension = extension.ToUpper();
 71 |             extension = extension.Insert(0, ".");
 72 | 
 73 |             return AllSupportedExtensions.Contains(extension);
 74 |         }
 75 | 
 76 |         #endregion
 77 | 
 78 |         #region private methods
 79 | 
 80 |         /// <summary>
 81 |         /// Re-calculate which extensions are available on this system. It's unlikely this ever needs to be called outside of the constructor.
 82 |         /// </summary>
 83 |         private void RecalculateExtensions()
 84 |         {
 85 |             CustomSupportedExtensions = GetSupportedExtensions().ToArray();
 86 |             NativeSupportedExtensions = new[] { ".BMP", ".GIF", ".ICO", ".JPEG", ".PNG", ".TIFF", ".DDS", ".JPG", ".JXR", ".HDP", ".WDP" };
 87 | 
 88 |             var cse = CustomSupportedExtensions;
 89 |             var nse = NativeSupportedExtensions;
 90 |             var ase = new string[cse.Length + nse.Length];
 91 |             Array.Copy(nse, ase, nse.Length);
 92 |             Array.Copy(cse, 0, ase, nse.Length, cse.Length);
 93 |             AllSupportedExtensions = ase;
 94 |         }
 95 | 
 96 |         /// <summary>
 97 |         /// Represents information about a WIC decoder
 98 |         /// </summary>
 99 |         private struct DecoderInfo
100 |         {
101 |             public string FriendlyName;
102 |             public string FileExtensions;
103 |         }
104 | 
105 |         /// <summary>
106 |         /// Gets a list of additionally registered WIC decoders
107 |         /// </summary>
108 |         /// <returns></returns>
109 |         private IEnumerable<DecoderInfo> GetAdditionalDecoders()
110 |         {
111 |             return GetCodecKeys().Select(codecKey => new DecoderInfo
112 |             {
113 |                 FriendlyName = Convert.ToString(codecKey.GetValue("FriendlyName", string.Empty)), FileExtensions = Convert.ToString(codecKey.GetValue("FileExtensions", string.Empty))
114 |             }).ToList();
115 |         }
116 | 
117 |         private List<string> GetSupportedExtensions()
118 |         {
119 |             var decoders = GetAdditionalDecoders();
120 | 
121 |             return decoders.SelectMany(decoder => decoder.FileExtensions.Split(',')).ToList();
122 |         }
123 | 
124 |         private IEnumerable<RegistryKey> GetCodecKeys()
125 |         {
126 |             var result = new List<RegistryKey>();
127 | 
128 |             var categoryKey = _baseKey?.OpenSubKey(WicDecoderCategory + "\\instance", false);
129 |             if (categoryKey == null) return result;
130 | 
131 |             result.AddRange(GetCodecGuids().Select(codecGuid => _baseKey.OpenSubKey(codecGuid)).Where(codecKey => codecKey != null));
132 | 
133 |             return result;
134 |         }
135 | 
136 |         private IEnumerable<string> GetCodecGuids()
137 |         {
138 |             var categoryKey = _baseKey?.OpenSubKey(WicDecoderCategory + "\\instance", false);
139 | 
140 |             // Read the guids of the registered decoders
141 |             return categoryKey?.GetSubKeyNames();
142 |         }
143 | 
144 |         #endregion
145 | 
146 | 
147 |         #region overrides and whatnot
148 | 
149 |         public override string ToString()
150 |         {
151 |             var rtnstring = string.Empty;
152 | 
153 |             rtnstring += "\nNative support for the following extensions is available: ";
154 |             rtnstring = NativeSupportedExtensions.Aggregate(rtnstring, (current, item) => current + (item + ","));
155 |             if (NativeSupportedExtensions.Any()) rtnstring = rtnstring.Remove(rtnstring.Length - 1);
156 | 
157 |             var decoders = GetAdditionalDecoders();
158 |             var decoderInfos = decoders as DecoderInfo[] ?? decoders.ToArray();
159 |             if (decoderInfos.Count() == 0) rtnstring += "\n\nNo custom decoders found.";
160 |             else
161 |             {
162 |                 rtnstring += "\n\nThese custom decoders were also found:";
163 |                 rtnstring = decoderInfos.Aggregate(rtnstring, (current, decoder) => current + ("\n" + decoder.FriendlyName + ", supporting extensions " + decoder.FileExtensions));
164 |             }
165 | 
166 |             return rtnstring;
167 |         }
168 | 
169 |         public void Dispose()
170 |         {
171 |             _baseKey.Dispose();
172 |         }
173 | 
174 |         #endregion
175 |     }
176 | }
177 | 


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


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