commit 60eb406cbed5fffa615576ecd8441e874135887c
Author: NickAppLab <nikolai-sm1996@yandex.ru>
Date:   Mon Jun 13 21:24:13 2022 +0500

    Init commit

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..c85668a
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,3 @@
+*\obj
+*\bin
+*\packages
diff --git a/App.config b/App.config
new file mode 100644
index 0000000..56efbc7
--- /dev/null
+++ b/App.config
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<configuration>
+    <startup> 
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2" />
+    </startup>
+</configuration>
\ No newline at end of file
diff --git a/App.xaml b/App.xaml
new file mode 100644
index 0000000..52c6648
--- /dev/null
+++ b/App.xaml
@@ -0,0 +1,9 @@
+<Application x:Class="StructureHelper.App"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:local="clr-namespace:StructureHelper"
+             StartupUri="Windows/MainWindow/MainView.xaml">
+    <Application.Resources>
+         
+    </Application.Resources>
+</Application>
diff --git a/App.xaml.cs b/App.xaml.cs
new file mode 100644
index 0000000..a696ce9
--- /dev/null
+++ b/App.xaml.cs
@@ -0,0 +1,11 @@
+using System.Windows;
+
+namespace StructureHelper
+{
+    /// <summary>
+    /// Логика взаимодействия для App.xaml
+    /// </summary>
+    public partial class App : Application
+    {
+    }
+}
diff --git a/Infrastructure/EventArgs.cs b/Infrastructure/EventArgs.cs
new file mode 100644
index 0000000..d22d52a
--- /dev/null
+++ b/Infrastructure/EventArgs.cs
@@ -0,0 +1,13 @@
+using System;
+
+namespace StructureHelper
+{
+    public class EventArgs<T> : EventArgs
+    {
+        public EventArgs(T value)
+        {
+            Value = value;
+        }
+        public T Value { get; private set; }
+    }
+}
diff --git a/Infrastructure/EventTriggerBase.cs b/Infrastructure/EventTriggerBase.cs
new file mode 100644
index 0000000..55172f4
--- /dev/null
+++ b/Infrastructure/EventTriggerBase.cs
@@ -0,0 +1,25 @@
+using System;
+using System.Windows;
+using EventTrigger = System.Windows.Interactivity.EventTrigger;
+
+namespace StructureHelper
+{
+    public class EventTriggerBase<T> : EventTrigger where T : RoutedEventArgs
+    {
+        readonly Predicate<T> eventTriggerPredicate;
+
+        public EventTriggerBase(Predicate<T> eventTriggerPredicate)
+        {
+            this.eventTriggerPredicate = eventTriggerPredicate;
+        }
+
+        protected override void OnEvent(EventArgs eventArgs)
+        {
+            if (eventArgs is T e && eventTriggerPredicate(e))
+            {
+                base.OnEvent(eventArgs);
+                e.Handled = true;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Infrastructure/Extensions/ObservableCollectionExtensions.cs b/Infrastructure/Extensions/ObservableCollectionExtensions.cs
new file mode 100644
index 0000000..4133fbd
--- /dev/null
+++ b/Infrastructure/Extensions/ObservableCollectionExtensions.cs
@@ -0,0 +1,31 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+namespace StructureHelper
+{
+    public static class ObservableCollectionExtensions
+    {
+        public static void MoveElementToEnd<T>(this ObservableCollection<T> collection, T element)
+        {
+            var elementCopy = element;
+            collection.Remove(element);
+            collection.Add(elementCopy);
+        }
+
+        public static void MoveElementToBegin<T>(this ObservableCollection<T> collection, T element)
+        {
+            var collectionCopy = new List<T>(collection);
+            collectionCopy.Remove(element);
+            collection.Clear();
+            collection.Add(element);
+            foreach (var collectionElem in collectionCopy)
+                collection.Add(collectionElem);
+        }
+
+        public static void MoveElementToSelectedIndex<T>(this ObservableCollection<T> collection, T element, int index)
+        {
+            collection.Remove(element);
+            collection.Insert(index - 1, element);
+        }
+    }
+}
diff --git a/Infrastructure/MouseBehaviour.cs b/Infrastructure/MouseBehaviour.cs
new file mode 100644
index 0000000..c6eae71
--- /dev/null
+++ b/Infrastructure/MouseBehaviour.cs
@@ -0,0 +1,45 @@
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using System.Windows.Interactivity;
+
+namespace StructureHelper
+{
+    public class MouseBehaviour : Behavior<Panel>
+    {
+        public static readonly DependencyProperty MouseYProperty = DependencyProperty.Register(
+            "MouseY", typeof(double), typeof(MouseBehaviour), new PropertyMetadata(default(double)));
+
+        public static readonly DependencyProperty MouseXProperty = DependencyProperty.Register(
+            "MouseX", typeof(double), typeof(MouseBehaviour), new PropertyMetadata(default(double)));
+
+        public double MouseY
+        {
+            get => (double)GetValue(MouseYProperty);
+            set => SetValue(MouseYProperty, value);
+        }
+
+        public double MouseX
+        {
+            get => (double)GetValue(MouseXProperty);
+            set => SetValue(MouseXProperty, value);
+        }
+
+        protected override void OnAttached()
+        {
+            AssociatedObject.MouseMove += AssociatedObjectOnMouseMove;
+        }
+
+        protected override void OnDetaching()
+        {
+            AssociatedObject.MouseMove -= AssociatedObjectOnMouseMove;
+        }
+
+        private void AssociatedObjectOnMouseMove(object sender, MouseEventArgs mouseEventArgs)
+        {
+            var pos = mouseEventArgs.GetPosition(AssociatedObject);
+            MouseX = pos.X;
+            MouseY = pos.Y;
+        }
+    }
+}
diff --git a/Infrastructure/MouseEventTriggers/DoubleClickEventTrigger.cs b/Infrastructure/MouseEventTriggers/DoubleClickEventTrigger.cs
new file mode 100644
index 0000000..0219791
--- /dev/null
+++ b/Infrastructure/MouseEventTriggers/DoubleClickEventTrigger.cs
@@ -0,0 +1,9 @@
+using System.Windows.Input;
+
+namespace StructureHelper.Infrastructure
+{
+    public class DoubleClickEventTrigger : EventTriggerBase<MouseButtonEventArgs>
+    {
+        public DoubleClickEventTrigger() : base(args => args.ClickCount == 2) { }
+    }
+}
diff --git a/Infrastructure/MouseEventTriggers/MouseWheelDownEventTrigger.cs b/Infrastructure/MouseEventTriggers/MouseWheelDownEventTrigger.cs
new file mode 100644
index 0000000..bea8b3b
--- /dev/null
+++ b/Infrastructure/MouseEventTriggers/MouseWheelDownEventTrigger.cs
@@ -0,0 +1,9 @@
+using System.Windows.Input;
+
+namespace StructureHelper.Infrastructure
+{
+    public class MouseWheelDownEventTrigger : EventTriggerBase<MouseWheelEventArgs>
+    {
+        public MouseWheelDownEventTrigger() : base(args => args.Delta > 0) { }
+    }
+}
diff --git a/Infrastructure/MouseEventTriggers/MouseWheelUpEventTrigger.cs b/Infrastructure/MouseEventTriggers/MouseWheelUpEventTrigger.cs
new file mode 100644
index 0000000..18195c8
--- /dev/null
+++ b/Infrastructure/MouseEventTriggers/MouseWheelUpEventTrigger.cs
@@ -0,0 +1,9 @@
+using System.Windows.Input;
+
+namespace StructureHelper.Infrastructure
+{
+    public class MouseWheelUpEventTrigger : EventTriggerBase<MouseWheelEventArgs>
+    {
+        public MouseWheelUpEventTrigger() : base(args => args.Delta < 0) { }
+    }
+}
\ No newline at end of file
diff --git a/Infrastructure/NamedList.cs b/Infrastructure/NamedList.cs
new file mode 100644
index 0000000..2587a29
--- /dev/null
+++ b/Infrastructure/NamedList.cs
@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace StructureHelper.Infrastructure
+{
+    public class NamedList<T> : List<T>
+    {
+        public string Name { get; set; }
+    }
+}
diff --git a/Infrastructure/RelayCommand.cs b/Infrastructure/RelayCommand.cs
new file mode 100644
index 0000000..61ccaf4
--- /dev/null
+++ b/Infrastructure/RelayCommand.cs
@@ -0,0 +1,27 @@
+using System;
+using System.Windows.Input;
+
+namespace StructureHelper
+{
+    public class RelayCommand : ICommand
+    {
+        private Action<object> execute;
+        private Func<object, bool> canExecute;
+
+        public event EventHandler CanExecuteChanged
+        {
+            add => CommandManager.RequerySuggested += value;
+            remove => CommandManager.RequerySuggested -= value;
+        }
+
+        public RelayCommand(Action<object> execute, Func<object, bool> canExecute = null)
+        {
+            this.execute = execute;
+            this.canExecute = canExecute;
+        }
+
+        public bool CanExecute(object parameter) => canExecute == null || canExecute(parameter);
+
+        public void Execute(object parameter) => execute(parameter);
+    }
+}
diff --git a/Infrastructure/ViewModelBase.cs b/Infrastructure/ViewModelBase.cs
new file mode 100644
index 0000000..337216b
--- /dev/null
+++ b/Infrastructure/ViewModelBase.cs
@@ -0,0 +1,27 @@
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
+using StructureHelper.Annotations;
+
+namespace StructureHelper.Infrastructure
+{
+    public class ViewModelBase : INotifyPropertyChanged
+    {
+        public event PropertyChangedEventHandler PropertyChanged;
+        [NotifyPropertyChangedInvocator]
+        protected virtual void OnPropertyChanged<T>(T value, T prop, [CallerMemberName] string propertyName = null)
+        {
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
+
+        [NotifyPropertyChangedInvocator]
+        protected virtual void OnPropertyChanged<T>(T value, ref T prop, [CallerMemberName] string propertyName = null)
+        {
+            prop = value;
+            OnPropertyChanged(propertyName);
+        }
+
+        [NotifyPropertyChangedInvocator]
+        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
+            => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+    }
+}
diff --git a/MaterialCatalogWindow/MaterialCatalogModel.cs b/MaterialCatalogWindow/MaterialCatalogModel.cs
new file mode 100644
index 0000000..2fb270b
--- /dev/null
+++ b/MaterialCatalogWindow/MaterialCatalogModel.cs
@@ -0,0 +1,58 @@
+using System.Collections.Generic;
+using StructureHelper.Infrastructure;
+
+namespace StructureHelper
+{
+    public class MaterialCatalogModel
+    {
+        public NamedList<MaterialDefinitionBase> ConcreteDefinitions;
+        public NamedList<MaterialDefinitionBase> RebarDefinitions;
+
+        public List<NamedList<MaterialDefinitionBase>> Materials;
+
+        public MaterialCatalogModel()
+        {
+            InitializeMaterialCollections();
+            Materials = new List<NamedList<MaterialDefinitionBase>>();
+            Materials.Add(ConcreteDefinitions);
+            Materials.Add(RebarDefinitions);
+        }
+
+        public void InitializeMaterialCollections()
+        {
+            InitializeConcreteDefinitions();
+            InitializeRebarDefinitions();
+        }
+
+        private void InitializeRebarDefinitions()
+        {
+            RebarDefinitions = new NamedList<MaterialDefinitionBase>()
+            {
+                new RebarDefinition("S240", 2, 240, 240, 1.15, 1.15),
+                new RebarDefinition("S400", 2, 400, 400, 1.15, 1.15),
+                new RebarDefinition("S500", 2, 500, 500, 1.15, 1.15)
+            };
+            RebarDefinitions.Name = "Арматура";
+        }
+
+        private void InitializeConcreteDefinitions()
+        {
+            ConcreteDefinitions = new NamedList<MaterialDefinitionBase>()
+            {
+                new ConcreteDefinition("C10", 0, 10, 0, 1.3, 1.5),
+                new ConcreteDefinition("C15", 0, 15, 0, 1.3, 1.5),
+                new ConcreteDefinition("C20", 0, 20, 0, 1.3, 1.5),
+                new ConcreteDefinition("C25", 0, 25, 0, 1.3, 1.5),
+                new ConcreteDefinition("C30", 0, 30, 0, 1.3, 1.5),
+                new ConcreteDefinition("C35", 0, 35, 0, 1.3, 1.5),
+                new ConcreteDefinition("C40", 0, 40, 0, 1.3, 1.5),
+                new ConcreteDefinition("C45", 0, 45, 0, 1.3, 1.5),
+                new ConcreteDefinition("C50", 0, 50, 0, 1.3, 1.5),
+                new ConcreteDefinition("C60", 0, 60, 0, 1.3, 1.5),
+                new ConcreteDefinition("C70", 0, 70, 0, 1.3, 1.5),
+                new ConcreteDefinition("C80", 0, 80, 0, 1.3, 1.5)
+            };
+            ConcreteDefinitions.Name = "Бетон";
+        }
+    }
+}
diff --git a/MaterialCatalogWindow/MaterialCatalogView.xaml b/MaterialCatalogWindow/MaterialCatalogView.xaml
new file mode 100644
index 0000000..48e0a1c
--- /dev/null
+++ b/MaterialCatalogWindow/MaterialCatalogView.xaml
@@ -0,0 +1,80 @@
+<Window x:Class="StructureHelper.MaterialCatalogView"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+        xmlns:local="clr-namespace:StructureHelper"
+        mc:Ignorable="d"
+        d:DataContext="{d:DesignInstance local:MaterialCatalogViewModel}"
+        Title="Справочник материалов" Height="900" Width="1100">
+    <Window.Resources>
+        <DataTemplate x:Key="RebarYoungModulusTemplate">
+            <StackPanel Orientation="Horizontal">
+                <TextBox VerticalAlignment="Center" HorizontalAlignment="Left" Margin="5,0" Text="{Binding YoungModulus}"/>
+                <TextBlock VerticalAlignment="Center" HorizontalAlignment="Left" Text=" x 10^11"/>
+            </StackPanel>
+        </DataTemplate>
+        <DataTemplate x:Key="CompressiveStrengthTemplate">
+            <StackPanel Orientation="Horizontal">
+                <TextBox VerticalAlignment="Center" HorizontalAlignment="Left" Margin="5,0" Text="{Binding CompressiveStrength}"/>
+                <TextBlock VerticalAlignment="Center" HorizontalAlignment="Left" Text=" x 10^6"/>
+            </StackPanel>
+        </DataTemplate>
+        <DataTemplate x:Key="TensileStrengthTemplate">
+            <StackPanel Orientation="Horizontal">
+                <TextBox VerticalAlignment="Center" HorizontalAlignment="Left" Margin="5,0" Text="{Binding TensileStrength}"/>
+                <TextBlock VerticalAlignment="Center" HorizontalAlignment="Left" Text=" x 10^6"/>
+            </StackPanel>
+        </DataTemplate>
+        <DataTemplate x:Key="MaterialClassTemplate">
+            <TextBox VerticalAlignment="Center" HorizontalAlignment="Left" Margin="5,0" Text="{Binding MaterialClass}"/>
+        </DataTemplate>
+        <DataTemplate x:Key="MaterialCoefInCompressTemplate">
+            <TextBox VerticalAlignment="Center" HorizontalAlignment="Left" Margin="5,0" Text="{Binding MaterialCoefInCompress}"/>
+        </DataTemplate>
+        <DataTemplate x:Key="MaterialCoefInTensionTemplate">
+            <TextBox VerticalAlignment="Center" HorizontalAlignment="Left" Margin="5,0" Text="{Binding MaterialCoefInTension}"/>
+        </DataTemplate>
+    </Window.Resources>
+    <Grid>
+        <Grid.RowDefinitions>
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="40"/>
+        </Grid.RowDefinitions>
+        <StackPanel Grid.Row="0" Margin="10">
+            <TextBlock VerticalAlignment="Center" HorizontalAlignment="Center" Margin="10,20,10,10" Text="Бетон" FontSize="16"/>
+            <DataGrid ItemsSource="{Binding ConcreteDefinitions}" AutoGenerateColumns="False" SelectedItem="{Binding SelectedMaterial}">
+                <DataGrid.Columns>
+                    <DataGridTemplateColumn Header="Класс" CellTemplate="{StaticResource MaterialClassTemplate}"/>
+                    <DataGridTextColumn Header="Модуль упругости" Binding="{Binding YoungModulus, StringFormat={}{0} x 10^6}" IsReadOnly="True"/>
+                    <DataGridTemplateColumn Header="Нормативная прочность на сжатие" CellTemplate="{StaticResource CompressiveStrengthTemplate}"/>
+                    <DataGridTextColumn Header="Нормативная прочность на растяжение" Binding="{Binding TensileStrength, StringFormat={}{0} x 10^3}" IsReadOnly="True"/>
+                    <DataGridTemplateColumn Header="Коэффициент надежности при сжатии" CellTemplate="{StaticResource MaterialCoefInCompressTemplate}"/>
+                    <DataGridTemplateColumn Header="Коэффициент надежности при растяжении" CellTemplate="{StaticResource MaterialCoefInTensionTemplate}"/>
+                </DataGrid.Columns>
+            </DataGrid>
+            <TextBlock VerticalAlignment="Center" HorizontalAlignment="Center" Margin="10,20,10,10" Text="Арматура" FontSize="16"/>
+            <DataGrid ItemsSource="{Binding RebarDefinitions}" AutoGenerateColumns="False" SelectedItem="{Binding SelectedMaterial}">
+                <DataGrid.Columns>
+                    <DataGridTemplateColumn Header="Класс" CellTemplate="{StaticResource MaterialClassTemplate}"/>
+                    <DataGridTemplateColumn Header="Модуль упругости" CellTemplate="{StaticResource RebarYoungModulusTemplate}"/>
+                    <DataGridTemplateColumn Header="Нормативная прочность на сжатие" CellTemplate="{StaticResource CompressiveStrengthTemplate}"/>
+                    <DataGridTemplateColumn Header="Нормативная прочность на растяжение" CellTemplate="{StaticResource TensileStrengthTemplate}"/>
+                    <DataGridTemplateColumn Header="Коэффициент надежности при сжатии" CellTemplate="{StaticResource MaterialCoefInCompressTemplate}"/>
+                    <DataGridTemplateColumn Header="Коэффициент надежности при растяжении" CellTemplate="{StaticResource MaterialCoefInTensionTemplate}"/>
+                </DataGrid.Columns>
+            </DataGrid>
+        </StackPanel>
+        <Grid Grid.Row="1">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="300"/>
+                <ColumnDefinition Width="*"/>
+                <ColumnDefinition Width="300"/>
+            </Grid.ColumnDefinitions>
+            <Button Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Left" Content="Добавить материал" Margin="10" Command="{Binding AddMaterial}"/>
+            <Button Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Выбрать материал" Margin="10" Command="{Binding SelectMaterial}" Visibility="{Binding SelectMaterialButtonVisibility}"/>
+            <Button Grid.Column="2" VerticalAlignment="Center" HorizontalAlignment="Left" Content="Сохранить справочник" Margin="10" Command="{Binding SaveCatalog}"/>
+            <Button Grid.Column="2" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Загрузить справочник" Margin="10" Command="{Binding LoadCatalog}"/>
+        </Grid>
+    </Grid>
+</Window>
diff --git a/MaterialCatalogWindow/MaterialCatalogView.xaml.cs b/MaterialCatalogWindow/MaterialCatalogView.xaml.cs
new file mode 100644
index 0000000..4ca8795
--- /dev/null
+++ b/MaterialCatalogWindow/MaterialCatalogView.xaml.cs
@@ -0,0 +1,18 @@
+using System.Windows;
+
+namespace StructureHelper
+{
+    /// <summary>
+    /// Логика взаимодействия для MaterialCatalogView.xaml
+    /// </summary>
+    public partial class MaterialCatalogView : Window
+    {
+        public MaterialCatalogView(bool isMaterialCanBeSelected = false, PrimitiveDefinition primitive = null)
+        {
+            var materialCatalogModel = new MaterialCatalogModel();
+            var materialCatalogViewModel = new MaterialCatalogViewModel(materialCatalogModel, this, isMaterialCanBeSelected, primitive);
+            DataContext = materialCatalogViewModel;
+            InitializeComponent();
+        }
+    }
+}
diff --git a/MaterialCatalogWindow/MaterialCatalogViewModel.cs b/MaterialCatalogWindow/MaterialCatalogViewModel.cs
new file mode 100644
index 0000000..dcce726
--- /dev/null
+++ b/MaterialCatalogWindow/MaterialCatalogViewModel.cs
@@ -0,0 +1,117 @@
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Windows;
+using System.Windows.Forms;
+using System.Windows.Input;
+using Newtonsoft.Json;
+using StructureHelper.Annotations;
+using OpenFileDialog = System.Windows.Forms.OpenFileDialog;
+using SaveFileDialog = System.Windows.Forms.SaveFileDialog;
+
+namespace StructureHelper
+{
+    [JsonObject(MemberSerialization.OptIn)]
+    public class MaterialCatalogViewModel : INotifyPropertyChanged
+    {
+        private MaterialCatalogModel materialCatalogModel;
+        private MaterialCatalogView materialCatalogView;
+
+        [JsonProperty]
+        public ObservableCollection<MaterialDefinitionBase> ConcreteDefinitions { get; set; }
+        [JsonProperty]
+        public ObservableCollection<MaterialDefinitionBase> RebarDefinitions { get; set; }
+        public ICommand AddMaterial { get; }
+        public ICommand SaveCatalog { get; }
+        public ICommand LoadCatalog { get; }
+        public ICommand SelectMaterial { get; }
+
+        private MaterialDefinitionBase selectedMaterial;
+        public MaterialDefinitionBase SelectedMaterial
+        {
+            get => selectedMaterial;
+            set
+            {
+                selectedMaterial = value;
+                OnPropertyChanged();
+            }
+        }
+
+        private bool isMaterialCanBeSelected;
+
+        public bool IsMaterialCanBeSelected
+        {
+            get => isMaterialCanBeSelected;
+            set
+            {
+                isMaterialCanBeSelected = value;
+                OnPropertyChanged();
+                OnPropertyChanged(nameof(SelectMaterialButtonVisibility));
+            }
+        }
+
+        public Visibility SelectMaterialButtonVisibility => IsMaterialCanBeSelected ? Visibility.Visible : Visibility.Hidden;
+        public MaterialCatalogViewModel() { }
+
+        public MaterialCatalogViewModel(MaterialCatalogModel materialCatalogModel, MaterialCatalogView materialCatalogView, bool isMaterialCanBeSelected, PrimitiveDefinition primitive = null)
+        {
+            this.materialCatalogModel = materialCatalogModel;
+            this.materialCatalogView = materialCatalogView;
+            IsMaterialCanBeSelected = isMaterialCanBeSelected;
+
+            ConcreteDefinitions = new ObservableCollection<MaterialDefinitionBase>(materialCatalogModel.ConcreteDefinitions);
+            RebarDefinitions = new ObservableCollection<MaterialDefinitionBase>(materialCatalogModel.RebarDefinitions);
+
+            AddMaterial = new RelayCommand(o =>
+            {
+                AddMaterialView addMaterialView = new AddMaterialView(this.materialCatalogModel, this);
+                addMaterialView.ShowDialog();
+                OnPropertyChanged(nameof(ConcreteDefinitions));
+                OnPropertyChanged(nameof(RebarDefinitions));
+            });
+            SaveCatalog = new RelayCommand(o =>
+            {
+                string json = JsonConvert.SerializeObject(this, Formatting.Indented);
+                SaveFileDialog saveDialog = new SaveFileDialog();
+                saveDialog.InitialDirectory = @"C:\";
+                saveDialog.Filter = "json files (*.json)|*.json|All files(*.*)|*.*";
+                string path = null;
+                if (saveDialog.ShowDialog() == DialogResult.OK)
+                {
+                    path = saveDialog.FileName;
+                    File.WriteAllText(path, json);
+                }
+            });
+            LoadCatalog = new RelayCommand(o =>
+            {
+                OpenFileDialog openFileDialog = new OpenFileDialog();
+                openFileDialog.InitialDirectory = @"C:\";
+                openFileDialog.Filter = "json files (*.json)|*.json|All files(*.*)|*.*";
+                if (openFileDialog.ShowDialog() == DialogResult.OK)
+                {
+                    var path = openFileDialog.FileName;
+                    var content = File.ReadAllText(path);
+                    var vm = JsonConvert.DeserializeObject<MaterialCatalogViewModel>(content);
+                    ConcreteDefinitions = vm.ConcreteDefinitions;
+                    OnPropertyChanged(nameof(ConcreteDefinitions));
+                    RebarDefinitions = vm.RebarDefinitions;
+                    OnPropertyChanged(nameof(RebarDefinitions));
+                }
+            });
+            SelectMaterial = new RelayCommand(o =>
+            {
+                if (primitive != null)
+                    primitive.Material = SelectedMaterial;
+            });
+        }
+
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        [NotifyPropertyChangedInvocator]
+        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
+        {
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
+    }
+}
diff --git a/MaterialDefinitions/ConcreteDefinition.cs b/MaterialDefinitions/ConcreteDefinition.cs
new file mode 100644
index 0000000..2d7c372
--- /dev/null
+++ b/MaterialDefinitions/ConcreteDefinition.cs
@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MaterialResistanceCalc
+{
+    public class ConcreteDefinition : MaterialDefinition
+    {
+        public ConcreteDefinition(string materialClass, double youngModulus, double compressiveStrengthCoef, double tensileStrengthCoef, double materialCoefInCompress, double materialCoefInTension)
+            : base(materialClass, youngModulus, compressiveStrengthCoef, tensileStrengthCoef, materialCoefInCompress, materialCoefInTension)
+        {
+            CompressiveStrength = compressiveStrengthCoef * Math.Pow(10, 6);
+            TensileStrength = tensileStrengthCoef * Math.Sqrt(CompressiveStrength);
+        }
+    }
+}
diff --git a/MaterialDefinitions/MaterialDefinition.cs b/MaterialDefinitions/MaterialDefinition.cs
new file mode 100644
index 0000000..c64a46e
--- /dev/null
+++ b/MaterialDefinitions/MaterialDefinition.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MaterialResistanceCalc
+{
+    public class MaterialDefinition
+    {
+        public string MaterialClass { get; set; }
+        public double YoungModulus { get; set; }
+        public double CompressiveStrength { get; set; }
+        public double TensileStrength { get; set; }
+        public double MaterialCoefInCompress { get; set; }
+        public double MaterialCoefInTension { get; set; }
+
+        public MaterialDefinition(string materialClass, double youngModulus, double compressiveStrengthCoef, double tensileStrengthCoef, double materialCoefInCompress, double materialCoefInTension)
+        {
+            MaterialClass = materialClass;
+            YoungModulus = youngModulus;
+            CompressiveStrength = compressiveStrengthCoef;
+            TensileStrength = tensileStrengthCoef;
+            MaterialCoefInCompress = materialCoefInCompress;
+            MaterialCoefInTension = materialCoefInTension;
+        }
+    }
+}
diff --git a/MaterialDefinitions/RebarDefinition.cs b/MaterialDefinitions/RebarDefinition.cs
new file mode 100644
index 0000000..2bbd3e6
--- /dev/null
+++ b/MaterialDefinitions/RebarDefinition.cs
@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MaterialResistanceCalc
+{
+    public class RebarDefinition : MaterialDefinition
+    {
+        public RebarDefinition(string materialClass, double youngModulus, double compressiveStrengthCoef, double tensileStrengthCoef, double materialCoefInCompress, double materialCoefInTension) : base(materialClass, youngModulus, compressiveStrengthCoef, tensileStrengthCoef, materialCoefInCompress, materialCoefInTension)
+        {
+            YoungModulus = youngModulus * Math.Pow(10, 11);
+            CompressiveStrength = compressiveStrengthCoef * Math.Pow(10, 6);
+            TensileStrength = tensileStrengthCoef * Math.Pow(10, 6);
+        }
+    }
+}
diff --git a/Models/MaterialDefinition/ConcreteDefinition.cs b/Models/MaterialDefinition/ConcreteDefinition.cs
new file mode 100644
index 0000000..d5b8714
--- /dev/null
+++ b/Models/MaterialDefinition/ConcreteDefinition.cs
@@ -0,0 +1,15 @@
+using System;
+
+namespace StructureHelper
+{
+    public class ConcreteDefinition : MaterialDefinitionBase
+    {
+        public ConcreteDefinition(string materialClass, double youngModulus, double compressiveStrengthCoef, double tensileStrengthCoef, double materialCoefInCompress, double materialCoefInTension)
+            : base(materialClass, youngModulus, compressiveStrengthCoef, tensileStrengthCoef, materialCoefInCompress, materialCoefInTension)
+        {
+            CompressiveStrength = compressiveStrengthCoef/* * Math.Pow(10, 6)*/;
+            TensileStrength = Math.Round(620 * Math.Sqrt(CompressiveStrength), 2);
+            YoungModulus = Math.Round(4.7 * Math.Sqrt(DesignCompressiveStrength), 2);
+        }
+    }
+}
diff --git a/Models/MaterialDefinition/MaterialDefinitionBase.cs b/Models/MaterialDefinition/MaterialDefinitionBase.cs
new file mode 100644
index 0000000..5e47163
--- /dev/null
+++ b/Models/MaterialDefinition/MaterialDefinitionBase.cs
@@ -0,0 +1,28 @@
+using System;
+
+namespace StructureHelper
+{
+    public class MaterialDefinitionBase
+    {
+        public string MaterialClass { get; set; }
+        public double YoungModulus { get; set; }
+        public double CompressiveStrength { get; set; }
+        public double TensileStrength { get; set; }
+        public double MaterialCoefInCompress { get; set; }
+        public double MaterialCoefInTension { get; set; }
+        public double DesignCompressiveStrength { get; set; }
+        public double DesingTensileStrength { get; set; }
+
+        public MaterialDefinitionBase(string materialClass, double youngModulus, double compressiveStrengthCoef, double tensileStrengthCoef, double materialCoefInCompress, double materialCoefInTension)
+        {
+            MaterialClass = materialClass;
+            YoungModulus = youngModulus;
+            CompressiveStrength = compressiveStrengthCoef;
+            TensileStrength = tensileStrengthCoef;
+            MaterialCoefInCompress = materialCoefInCompress;
+            MaterialCoefInTension = materialCoefInTension;
+            DesignCompressiveStrength = compressiveStrengthCoef * Math.Pow(10, 6) * 1 / 1;
+            DesingTensileStrength = tensileStrengthCoef * Math.Pow(10, 3) * 1 / materialCoefInTension;
+        }
+    }
+}
diff --git a/Models/MaterialDefinition/RebarDefinition.cs b/Models/MaterialDefinition/RebarDefinition.cs
new file mode 100644
index 0000000..c9d8fe3
--- /dev/null
+++ b/Models/MaterialDefinition/RebarDefinition.cs
@@ -0,0 +1,12 @@
+namespace StructureHelper
+{
+    public class RebarDefinition : MaterialDefinitionBase
+    {
+        public RebarDefinition(string materialClass, double youngModulus, double compressiveStrengthCoef, double tensileStrengthCoef, double materialCoefInCompress, double materialCoefInTension) : base(materialClass, youngModulus, compressiveStrengthCoef, tensileStrengthCoef, materialCoefInCompress, materialCoefInTension)
+        {
+            YoungModulus = youngModulus/* * Math.Pow(10, 11)*/;
+            CompressiveStrength = compressiveStrengthCoef/* * Math.Pow(10, 6)*/;
+            TensileStrength = tensileStrengthCoef/* * Math.Pow(10, 6)*/;
+        }
+    }
+}
diff --git a/Models/PrimitiveDefinition/EllipseDefinition.cs b/Models/PrimitiveDefinition/EllipseDefinition.cs
new file mode 100644
index 0000000..e2ae828
--- /dev/null
+++ b/Models/PrimitiveDefinition/EllipseDefinition.cs
@@ -0,0 +1,103 @@
+using System;
+using System.Windows.Media;
+
+namespace StructureHelper
+{
+    public class EllipseDefinition : PrimitiveDefinitionBase
+    {
+        private double diameter, showedDiameter, ellipseX, ellipseY;
+        public double Diameter
+        {
+            get => diameter;
+            set
+            {
+                diameter = value;
+                ShowedDiameter = Math.Round(value, 2);
+                OnPropertyChanged();
+            }
+        }
+        public double ShowedDiameter
+        {
+            get => showedDiameter;
+            set
+            {
+                showedDiameter = value;
+                OnPropertyChanged();
+            }
+        }
+
+        public double EllipseX
+        {
+            get => ellipseX;
+            set
+            {
+                ellipseX = value;
+                OnPropertyChanged();
+            }
+        }
+        public double EllipseY
+        {
+            get => ellipseY;
+            set
+            {
+                ellipseY = value;
+                OnPropertyChanged();
+            }
+        }
+        
+        
+        private double showedEllipseX, showedEllipseY;
+        private double initialEllipseX, initialEllipseY;
+        public double ShowedEllipseX
+        {
+            get => showedEllipseX;
+            set
+            {
+                showedEllipseX = value;
+                EllipseX = value + initialEllipseX - Diameter / 2;
+                OnPropertyChanged(nameof(EllipseX));
+                OnPropertyChanged();
+            }
+        }
+        public double ShowedEllipseY
+        {
+            get => showedEllipseY;
+            set
+            {
+                showedEllipseY = value;
+                EllipseY = -value + initialEllipseY - Diameter / 2;
+                OnPropertyChanged(nameof(ShowedEllipseY));
+                OnPropertyChanged();
+            }
+        }
+        
+        
+
+        private double square;
+        public double Square
+        {
+            get => square;
+            set
+            {
+                square = value;
+                Diameter = Math.Sqrt(4 * value / Math.PI);
+                OnPropertyChanged(nameof(Diameter));
+                OnPropertyChanged();
+            }
+        }
+
+        public EllipseDefinition(double square, double ellipseX, double ellipseY)
+        {
+            Square = square;
+            initialEllipseX = ellipseX;
+            initialEllipseY = ellipseY;
+            ShowedEllipseX = 0;
+            ShowedEllipseY = 0;
+            var randomR = new Random().Next(150, 255);
+            var randomG = new Random().Next(0, 255);
+            var randomB = new Random().Next(30, 130);
+            var color = Color.FromRgb((byte)randomR, (byte)randomG, (byte)randomB);
+            Brush = new SolidColorBrush(color);
+        }
+    }
+}
diff --git a/Models/PrimitiveDefinition/PrimitiveDefinitionBase.cs b/Models/PrimitiveDefinition/PrimitiveDefinitionBase.cs
new file mode 100644
index 0000000..8c6b23e
--- /dev/null
+++ b/Models/PrimitiveDefinition/PrimitiveDefinitionBase.cs
@@ -0,0 +1,146 @@
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
+using System.Windows.Media;
+using StructureHelper.Annotations;
+
+namespace StructureHelper
+{
+    public class PrimitiveDefinitionBase : INotifyPropertyChanged
+    {
+        private bool captured, parameterCaptured, elementLock;
+
+        public bool Captured
+        {
+            set
+            {
+                captured = value;
+                OnPropertyChanged();
+            }
+            get => captured;
+        }
+        public bool ParameterCaptured
+        {
+            set
+            {
+                parameterCaptured = value;
+                OnPropertyChanged();
+            }
+            get => parameterCaptured;
+        }
+        public bool ElementLock
+        {
+            get => elementLock;
+            set
+            {
+                elementLock = value;
+                OnPropertyChanged();
+            }
+        }
+        private SolidColorBrush brush = null;
+        public SolidColorBrush Brush
+        {
+            get => brush;
+            set
+            {
+                brush = value;
+                OnPropertyChanged();
+            }
+        }
+        private MaterialDefinitionBase material = null;
+        public MaterialDefinitionBase Material
+        {
+            get => material;
+            set
+            {
+                material = value;
+                MaterialName = material.MaterialClass;
+                OnPropertyChanged();
+                OnPropertyChanged(nameof(MaterialName));
+            }
+        }
+        private string materialName = string.Empty;
+        public string MaterialName
+        {
+            get => materialName;
+            set
+            {
+                materialName = value;
+                OnPropertyChanged();
+            }
+        }
+        private bool paramsPanelVisibilty;
+        public bool ParamsPanelVisibilty
+        {
+            get => paramsPanelVisibilty;
+            set
+            {
+                paramsPanelVisibilty = value;
+                OnPropertyChanged();
+            }
+        }
+        private bool popupCanBeClosed = true;
+        public bool PopupCanBeClosed
+        {
+            get => popupCanBeClosed;
+            set
+            {
+                popupCanBeClosed = value;
+                OnPropertyChanged();
+            }
+        }
+        private double opacity = 1;
+        private double showedOpacity = 0;
+        public double ShowedOpacity
+        {
+            get => showedOpacity;
+            set
+            {
+                showedOpacity = value;
+                Opacity = (100 - value) / 100;
+                OnPropertyChanged(nameof(Opacity));
+                OnPropertyChanged();
+            }
+        }
+        public double Opacity
+        {
+            get => opacity;
+            set
+            {
+                opacity = value;
+                OnPropertyChanged();
+            }
+        }
+        private int showedZIndex = 1;
+        public int ShowedZIndex
+        {
+            get => showedZIndex;
+            set
+            {
+                showedZIndex = value;
+                ZIndex = value - 1;
+                OnPropertyChanged(nameof(ZIndex));
+                OnPropertyChanged();
+            }
+        }
+
+        private int zIndex;
+        public int ZIndex
+        {
+            get => zIndex;
+            set
+            {
+                zIndex = value;
+                OnPropertyChanged();
+            }
+        }
+
+
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        [NotifyPropertyChangedInvocator]
+        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
+        {
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
+    }
+}
diff --git a/Models/PrimitiveDefinition/RectangleDefinition.cs b/Models/PrimitiveDefinition/RectangleDefinition.cs
new file mode 100644
index 0000000..bad86f7
--- /dev/null
+++ b/Models/PrimitiveDefinition/RectangleDefinition.cs
@@ -0,0 +1,97 @@
+using System;
+using System.Windows.Media;
+
+namespace StructureHelper
+{
+    public class RectangleDefinition : PrimitiveDefinitionBase
+    {
+        private bool borderCaptured = false;
+        private double rectX, rectY, borderWidth, borderHeight;
+        
+        public bool BorderCaptured
+        {
+            set
+            {
+                borderCaptured = value;
+                OnPropertyChanged();
+            }
+            get => borderCaptured;
+        }
+        
+        public double RectX
+        {
+            get => rectX;
+            set
+            {
+                rectX = value;
+                OnPropertyChanged();
+            }
+        }
+        public double RectY
+        {
+            get => rectY;
+            set
+            {
+                rectY = value;
+                OnPropertyChanged();
+            }
+        }
+        private double showedRectX, showedRectY;
+        private double initialRectX, initialRectY;
+        public double ShowedRectX
+        {
+            get => showedRectX;
+            set
+            {
+                showedRectX = value;
+                RectX = value + initialRectX;
+                OnPropertyChanged(nameof(RectX));
+                OnPropertyChanged();
+            }
+        }
+        public double ShowedRectY
+        {
+            get => showedRectY;
+            set
+            {
+                showedRectY = value;
+                RectY = -value + initialRectY - BorderHeight;
+                OnPropertyChanged(nameof(RectY));
+                OnPropertyChanged();
+            }
+        }
+        public double BorderWidth
+        {
+            get => borderWidth;
+            set
+            {
+                borderWidth = value;
+                OnPropertyChanged();
+            }
+        }
+        public double BorderHeight
+        {
+            get => borderHeight;
+            set
+            {
+                borderHeight = value;
+                OnPropertyChanged();
+            }
+        }
+
+        public RectangleDefinition(double borderWidth, double borderHeight, double rectX, double rectY)
+        {
+            BorderWidth = borderWidth;
+            BorderHeight = borderHeight;
+            initialRectX = rectX;
+            initialRectY = rectY;
+            ShowedRectX = 0;
+            ShowedRectY = 0;
+            var randomR = new Random().Next(150, 255);
+            var randomG = new Random().Next(0, 255);
+            var randomB = new Random().Next(30, 130);
+            var color = Color.FromRgb((byte)randomR, (byte)randomG, (byte)randomB);
+            Brush = new SolidColorBrush(color);
+        }
+    }
+}
diff --git a/Properties/Annotations.cs b/Properties/Annotations.cs
new file mode 100644
index 0000000..7523de5
--- /dev/null
+++ b/Properties/Annotations.cs
@@ -0,0 +1,1603 @@
+/* MIT License
+
+Copyright (c) 2016 JetBrains http://www.jetbrains.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. */
+
+using System;
+// ReSharper disable UnusedType.Global
+
+#pragma warning disable 1591
+// ReSharper disable UnusedMember.Global
+// ReSharper disable MemberCanBePrivate.Global
+// ReSharper disable UnusedAutoPropertyAccessor.Global
+// ReSharper disable IntroduceOptionalParameters.Global
+// ReSharper disable MemberCanBeProtected.Global
+// ReSharper disable InconsistentNaming
+
+namespace StructureHelper.Annotations
+{
+  /// <summary>
+  /// Indicates that the value of the marked element could be <c>null</c> sometimes,
+  /// so checking for <c>null</c> is required before its usage.
+  /// </summary>
+  /// <example><code>
+  /// [CanBeNull] object Test() => null;
+  /// 
+  /// void UseTest() {
+  ///   var p = Test();
+  ///   var s = p.ToString(); // Warning: Possible 'System.NullReferenceException'
+  /// }
+  /// </code></example>
+  [AttributeUsage(
+    AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
+    AttributeTargets.Delegate | AttributeTargets.Field | AttributeTargets.Event |
+    AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.GenericParameter)]
+  public sealed class CanBeNullAttribute : Attribute { }
+
+  /// <summary>
+  /// Indicates that the value of the marked element can never be <c>null</c>.
+  /// </summary>
+  /// <example><code>
+  /// [NotNull] object Foo() {
+  ///   return null; // Warning: Possible 'null' assignment
+  /// }
+  /// </code></example>
+  [AttributeUsage(
+    AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
+    AttributeTargets.Delegate | AttributeTargets.Field | AttributeTargets.Event |
+    AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.GenericParameter)]
+  public sealed class NotNullAttribute : Attribute { }
+
+  /// <summary>
+  /// Can be applied to symbols of types derived from IEnumerable as well as to symbols of Task
+  /// and Lazy classes to indicate that the value of a collection item, of the Task.Result property
+  /// or of the Lazy.Value property can never be null.
+  /// </summary>
+  /// <example><code>
+  /// public void Foo([ItemNotNull]List&lt;string&gt; books)
+  /// {
+  ///   foreach (var book in books) {
+  ///     if (book != null) // Warning: Expression is always true
+  ///      Console.WriteLine(book.ToUpper());
+  ///   }
+  /// }
+  /// </code></example>
+  [AttributeUsage(
+    AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
+    AttributeTargets.Delegate | AttributeTargets.Field)]
+  public sealed class ItemNotNullAttribute : Attribute { }
+
+  /// <summary>
+  /// Can be applied to symbols of types derived from IEnumerable as well as to symbols of Task
+  /// and Lazy classes to indicate that the value of a collection item, of the Task.Result property
+  /// or of the Lazy.Value property can be null.
+  /// </summary>
+  /// <example><code>
+  /// public void Foo([ItemCanBeNull]List&lt;string&gt; books)
+  /// {
+  ///   foreach (var book in books)
+  ///   {
+  ///     // Warning: Possible 'System.NullReferenceException'
+  ///     Console.WriteLine(book.ToUpper());
+  ///   }
+  /// }
+  /// </code></example>
+  [AttributeUsage(
+    AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
+    AttributeTargets.Delegate | AttributeTargets.Field)]
+  public sealed class ItemCanBeNullAttribute : Attribute { }
+
+  /// <summary>
+  /// Indicates that the marked method builds string by the format pattern and (optional) arguments.
+  /// The parameter, which contains the format string, should be given in the constructor. The format string
+  /// should be in <see cref="string.Format(IFormatProvider,string,object[])"/>-like form.
+  /// </summary>
+  /// <example><code>
+  /// [StringFormatMethod("message")]
+  /// void ShowError(string message, params object[] args) { /* do something */ }
+  /// 
+  /// void Foo() {
+  ///   ShowError("Failed: {0}"); // Warning: Non-existing argument in format string
+  /// }
+  /// </code></example>
+  [AttributeUsage(
+    AttributeTargets.Constructor | AttributeTargets.Method |
+    AttributeTargets.Property | AttributeTargets.Delegate)]
+  public sealed class StringFormatMethodAttribute : Attribute
+  {
+    /// <param name="formatParameterName">
+    /// Specifies which parameter of an annotated method should be treated as the format string
+    /// </param>
+    public StringFormatMethodAttribute([NotNull] string formatParameterName)
+    {
+      FormatParameterName = formatParameterName;
+    }
+
+    [NotNull] public string FormatParameterName { get; }
+  }
+
+  /// <summary>
+  /// Indicates that the marked parameter is a message template where placeholders are to be replaced by the following arguments
+  /// in the order in which they appear
+  /// </summary>
+  /// <example><code>
+  /// void LogInfo([StructuredMessageTemplate]string message, params object[] args) { /* do something */ }
+  /// 
+  /// void Foo() {
+  ///   LogInfo("User created: {username}"); // Warning: Non-existing argument in format string
+  /// }
+  /// </code></example>
+  [AttributeUsage(AttributeTargets.Parameter)]
+  public sealed class StructuredMessageTemplateAttribute : Attribute {}
+
+  /// <summary>
+  /// Use this annotation to specify a type that contains static or const fields
+  /// with values for the annotated property/field/parameter.
+  /// The specified type will be used to improve completion suggestions.
+  /// </summary>
+  /// <example><code>
+  /// namespace TestNamespace
+  /// {
+  ///   public class Constants
+  ///   {
+  ///     public static int INT_CONST = 1;
+  ///     public const string STRING_CONST = "1";
+  ///   }
+  ///
+  ///   public class Class1
+  ///   {
+  ///     [ValueProvider("TestNamespace.Constants")] public int myField;
+  ///     public void Foo([ValueProvider("TestNamespace.Constants")] string str) { }
+  ///
+  ///     public void Test()
+  ///     {
+  ///       Foo(/*try completion here*/);//
+  ///       myField = /*try completion here*/
+  ///     }
+  ///   }
+  /// }
+  /// </code></example>
+  [AttributeUsage(
+    AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.Field,
+    AllowMultiple = true)]
+  public sealed class ValueProviderAttribute : Attribute
+  {
+    public ValueProviderAttribute([NotNull] string name)
+    {
+      Name = name;
+    }
+
+    [NotNull] public string Name { get; }
+  }
+
+  /// <summary>
+  /// Indicates that the integral value falls into the specified interval.
+  /// It's allowed to specify multiple non-intersecting intervals.
+  /// Values of interval boundaries are inclusive.
+  /// </summary>
+  /// <example><code>
+  /// void Foo([ValueRange(0, 100)] int value) {
+  ///   if (value == -1) { // Warning: Expression is always 'false'
+  ///     ...
+  ///   }
+  /// }
+  /// </code></example>
+  [AttributeUsage(
+    AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property |
+    AttributeTargets.Method | AttributeTargets.Delegate,
+    AllowMultiple = true)]
+  public sealed class ValueRangeAttribute : Attribute
+  {
+    public object From { get; }
+    public object To { get; }
+
+    public ValueRangeAttribute(long from, long to)
+    {
+      From = from;
+      To = to;
+    }
+
+    public ValueRangeAttribute(ulong from, ulong to)
+    {
+      From = from;
+      To = to;
+    }
+
+    public ValueRangeAttribute(long value)
+    {
+      From = To = value;
+    }
+
+    public ValueRangeAttribute(ulong value)
+    {
+      From = To = value;
+    }
+  }
+
+  /// <summary>
+  /// Indicates that the integral value never falls below zero.
+  /// </summary>
+  /// <example><code>
+  /// void Foo([NonNegativeValue] int value) {
+  ///   if (value == -1) { // Warning: Expression is always 'false'
+  ///     ...
+  ///   }
+  /// }
+  /// </code></example>
+  [AttributeUsage(
+    AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property |
+    AttributeTargets.Method | AttributeTargets.Delegate)]
+  public sealed class NonNegativeValueAttribute : Attribute { }
+
+  /// <summary>
+  /// Indicates that the function argument should be a string literal and match one
+  /// of the parameters of the caller function. For example, ReSharper annotates
+  /// the parameter of <see cref="System.ArgumentNullException"/>.
+  /// </summary>
+  /// <example><code>
+  /// void Foo(string param) {
+  ///   if (param == null)
+  ///     throw new ArgumentNullException("par"); // Warning: Cannot resolve symbol
+  /// }
+  /// </code></example>
+  [AttributeUsage(AttributeTargets.Parameter)]
+  public sealed class InvokerParameterNameAttribute : Attribute { }
+
+  /// <summary>
+  /// Indicates that the method is contained in a type that implements
+  /// <c>System.ComponentModel.INotifyPropertyChanged</c> interface and this method
+  /// is used to notify that some property value changed.
+  /// </summary>
+  /// <remarks>
+  /// The method should be non-static and conform to one of the supported signatures:
+  /// <list>
+  /// <item><c>NotifyChanged(string)</c></item>
+  /// <item><c>NotifyChanged(params string[])</c></item>
+  /// <item><c>NotifyChanged{T}(Expression{Func{T}})</c></item>
+  /// <item><c>NotifyChanged{T,U}(Expression{Func{T,U}})</c></item>
+  /// <item><c>SetProperty{T}(ref T, T, string)</c></item>
+  /// </list>
+  /// </remarks>
+  /// <example><code>
+  /// public class Foo : INotifyPropertyChanged {
+  ///   public event PropertyChangedEventHandler PropertyChanged;
+  /// 
+  ///   [NotifyPropertyChangedInvocator]
+  ///   protected virtual void NotifyChanged(string propertyName) { ... }
+  ///
+  ///   string _name;
+  /// 
+  ///   public string Name {
+  ///     get { return _name; }
+  ///     set { _name = value; NotifyChanged("LastName"); /* Warning */ }
+  ///   }
+  /// }
+  /// </code>
+  /// Examples of generated notifications:
+  /// <list>
+  /// <item><c>NotifyChanged("Property")</c></item>
+  /// <item><c>NotifyChanged(() =&gt; Property)</c></item>
+  /// <item><c>NotifyChanged((VM x) =&gt; x.Property)</c></item>
+  /// <item><c>SetProperty(ref myField, value, "Property")</c></item>
+  /// </list>
+  /// </example>
+  [AttributeUsage(AttributeTargets.Method)]
+  public sealed class NotifyPropertyChangedInvocatorAttribute : Attribute
+  {
+    public NotifyPropertyChangedInvocatorAttribute() { }
+    public NotifyPropertyChangedInvocatorAttribute([NotNull] string parameterName)
+    {
+      ParameterName = parameterName;
+    }
+
+    [CanBeNull] public string ParameterName { get; }
+  }
+
+  /// <summary>
+  /// Describes dependency between method input and output.
+  /// </summary>
+  /// <syntax>
+  /// <p>Function Definition Table syntax:</p>
+  /// <list>
+  /// <item>FDT      ::= FDTRow [;FDTRow]*</item>
+  /// <item>FDTRow   ::= Input =&gt; Output | Output &lt;= Input</item>
+  /// <item>Input    ::= ParameterName: Value [, Input]*</item>
+  /// <item>Output   ::= [ParameterName: Value]* {halt|stop|void|nothing|Value}</item>
+  /// <item>Value    ::= true | false | null | notnull | canbenull</item>
+  /// </list>
+  /// If the method has a single input parameter, its name could be omitted.<br/>
+  /// Using <c>halt</c> (or <c>void</c>/<c>nothing</c>, which is the same) for the method output
+  /// means that the method doesn't return normally (throws or terminates the process).<br/>
+  /// Value <c>canbenull</c> is only applicable for output parameters.<br/>
+  /// You can use multiple <c>[ContractAnnotation]</c> for each FDT row, or use single attribute
+  /// with rows separated by the semicolon. There is no notion of order rows, all rows are checked
+  /// for applicability and applied per each program state tracked by the analysis engine.<br/>
+  /// </syntax>
+  /// <examples><list>
+  /// <item><code>
+  /// [ContractAnnotation("=&gt; halt")]
+  /// public void TerminationMethod()
+  /// </code></item>
+  /// <item><code>
+  /// [ContractAnnotation("null &lt;= param:null")] // reverse condition syntax
+  /// public string GetName(string surname)
+  /// </code></item>
+  /// <item><code>
+  /// [ContractAnnotation("s:null =&gt; true")]
+  /// public bool IsNullOrEmpty(string s) // string.IsNullOrEmpty()
+  /// </code></item>
+  /// <item><code>
+  /// // A method that returns null if the parameter is null,
+  /// // and not null if the parameter is not null
+  /// [ContractAnnotation("null =&gt; null; notnull =&gt; notnull")]
+  /// public object Transform(object data)
+  /// </code></item>
+  /// <item><code>
+  /// [ContractAnnotation("=&gt; true, result: notnull; =&gt; false, result: null")]
+  /// public bool TryParse(string s, out Person result)
+  /// </code></item>
+  /// </list></examples>
+  [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
+  public sealed class ContractAnnotationAttribute : Attribute
+  {
+    public ContractAnnotationAttribute([NotNull] string contract)
+      : this(contract, false) { }
+
+    public ContractAnnotationAttribute([NotNull] string contract, bool forceFullStates)
+    {
+      Contract = contract;
+      ForceFullStates = forceFullStates;
+    }
+
+    [NotNull] public string Contract { get; }
+
+    public bool ForceFullStates { get; }
+  }
+
+  /// <summary>
+  /// Indicates whether the marked element should be localized.
+  /// </summary>
+  /// <example><code>
+  /// [LocalizationRequiredAttribute(true)]
+  /// class Foo {
+  ///   string str = "my string"; // Warning: Localizable string
+  /// }
+  /// </code></example>
+  [AttributeUsage(AttributeTargets.All)]
+  public sealed class LocalizationRequiredAttribute : Attribute
+  {
+    public LocalizationRequiredAttribute() : this(true) { }
+
+    public LocalizationRequiredAttribute(bool required)
+    {
+      Required = required;
+    }
+
+    public bool Required { get; }
+  }
+
+  /// <summary>
+  /// Indicates that the value of the marked type (or its derivatives)
+  /// cannot be compared using '==' or '!=' operators and <c>Equals()</c>
+  /// should be used instead. However, using '==' or '!=' for comparison
+  /// with <c>null</c> is always permitted.
+  /// </summary>
+  /// <example><code>
+  /// [CannotApplyEqualityOperator]
+  /// class NoEquality { }
+  /// 
+  /// class UsesNoEquality {
+  ///   void Test() {
+  ///     var ca1 = new NoEquality();
+  ///     var ca2 = new NoEquality();
+  ///     if (ca1 != null) { // OK
+  ///       bool condition = ca1 == ca2; // Warning
+  ///     }
+  ///   }
+  /// }
+  /// </code></example>
+  [AttributeUsage(AttributeTargets.Interface | AttributeTargets.Class | AttributeTargets.Struct)]
+  public sealed class CannotApplyEqualityOperatorAttribute : Attribute { }
+
+  /// <summary>
+  /// When applied to a target attribute, specifies a requirement for any type marked
+  /// with the target attribute to implement or inherit specific type or types.
+  /// </summary>
+  /// <example><code>
+  /// [BaseTypeRequired(typeof(IComponent)] // Specify requirement
+  /// class ComponentAttribute : Attribute { }
+  /// 
+  /// [Component] // ComponentAttribute requires implementing IComponent interface
+  /// class MyComponent : IComponent { }
+  /// </code></example>
+  [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
+  [BaseTypeRequired(typeof(Attribute))]
+  public sealed class BaseTypeRequiredAttribute : Attribute
+  {
+    public BaseTypeRequiredAttribute([NotNull] Type baseType)
+    {
+      BaseType = baseType;
+    }
+
+    [NotNull] public Type BaseType { get; }
+  }
+
+  /// <summary>
+  /// Indicates that the marked symbol is used implicitly (e.g. via reflection, in external library),
+  /// so this symbol will be ignored by usage-checking inspections. <br/>
+  /// You can use <see cref="ImplicitUseKindFlags"/> and <see cref="ImplicitUseTargetFlags"/>
+  /// to configure how this attribute is applied.
+  /// </summary>
+  /// <example><code>
+  /// [UsedImplicitly]
+  /// public class TypeConverter {}
+  /// 
+  /// public class SummaryData
+  /// {
+  ///   [UsedImplicitly(ImplicitUseKindFlags.InstantiatedWithFixedConstructorSignature)]
+  ///   public SummaryData() {}
+  /// }
+  /// 
+  /// [UsedImplicitly(ImplicitUseTargetFlags.WithInheritors | ImplicitUseTargetFlags.Default)]
+  /// public interface IService {}
+  /// </code></example>
+  [AttributeUsage(AttributeTargets.All)]
+  public sealed class UsedImplicitlyAttribute : Attribute
+  {
+    public UsedImplicitlyAttribute()
+      : this(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Default) { }
+
+    public UsedImplicitlyAttribute(ImplicitUseKindFlags useKindFlags)
+      : this(useKindFlags, ImplicitUseTargetFlags.Default) { }
+
+    public UsedImplicitlyAttribute(ImplicitUseTargetFlags targetFlags)
+      : this(ImplicitUseKindFlags.Default, targetFlags) { }
+
+    public UsedImplicitlyAttribute(ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags)
+    {
+      UseKindFlags = useKindFlags;
+      TargetFlags = targetFlags;
+    }
+
+    public ImplicitUseKindFlags UseKindFlags { get; }
+
+    public ImplicitUseTargetFlags TargetFlags { get; }
+  }
+
+  /// <summary>
+  /// Can be applied to attributes, type parameters, and parameters of a type assignable from <see cref="System.Type"/> .
+  /// When applied to an attribute, the decorated attribute behaves the same as <see cref="UsedImplicitlyAttribute"/>.
+  /// When applied to a type parameter or to a parameter of type <see cref="System.Type"/>,
+  /// indicates that the corresponding type is used implicitly.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Class | AttributeTargets.GenericParameter | AttributeTargets.Parameter)]
+  public sealed class MeansImplicitUseAttribute : Attribute
+  {
+    public MeansImplicitUseAttribute()
+      : this(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Default) { }
+
+    public MeansImplicitUseAttribute(ImplicitUseKindFlags useKindFlags)
+      : this(useKindFlags, ImplicitUseTargetFlags.Default) { }
+
+    public MeansImplicitUseAttribute(ImplicitUseTargetFlags targetFlags)
+      : this(ImplicitUseKindFlags.Default, targetFlags) { }
+
+    public MeansImplicitUseAttribute(ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags)
+    {
+      UseKindFlags = useKindFlags;
+      TargetFlags = targetFlags;
+    }
+
+    [UsedImplicitly] public ImplicitUseKindFlags UseKindFlags { get; }
+
+    [UsedImplicitly] public ImplicitUseTargetFlags TargetFlags { get; }
+  }
+
+  /// <summary>
+  /// Specifies the details of implicitly used symbol when it is marked
+  /// with <see cref="MeansImplicitUseAttribute"/> or <see cref="UsedImplicitlyAttribute"/>.
+  /// </summary>
+  [Flags]
+  public enum ImplicitUseKindFlags
+  {
+    Default = Access | Assign | InstantiatedWithFixedConstructorSignature,
+    /// <summary>Only entity marked with attribute considered used.</summary>
+    Access = 1,
+    /// <summary>Indicates implicit assignment to a member.</summary>
+    Assign = 2,
+    /// <summary>
+    /// Indicates implicit instantiation of a type with fixed constructor signature.
+    /// That means any unused constructor parameters won't be reported as such.
+    /// </summary>
+    InstantiatedWithFixedConstructorSignature = 4,
+    /// <summary>Indicates implicit instantiation of a type.</summary>
+    InstantiatedNoFixedConstructorSignature = 8,
+  }
+
+  /// <summary>
+  /// Specifies what is considered to be used implicitly when marked
+  /// with <see cref="MeansImplicitUseAttribute"/> or <see cref="UsedImplicitlyAttribute"/>.
+  /// </summary>
+  [Flags]
+  public enum ImplicitUseTargetFlags
+  {
+    Default = Itself,
+    Itself = 1,
+    /// <summary>Members of the type marked with the attribute are considered used.</summary>
+    Members = 2,
+    /// <summary> Inherited entities are considered used. </summary>
+    WithInheritors = 4,
+    /// <summary>Entity marked with the attribute and all its members considered used.</summary>
+    WithMembers = Itself | Members
+  }
+
+  /// <summary>
+  /// This attribute is intended to mark publicly available API,
+  /// which should not be removed and so is treated as used.
+  /// </summary>
+  [MeansImplicitUse(ImplicitUseTargetFlags.WithMembers)]
+  [AttributeUsage(AttributeTargets.All, Inherited = false)]
+  public sealed class PublicAPIAttribute : Attribute
+  {
+    public PublicAPIAttribute() { }
+
+    public PublicAPIAttribute([NotNull] string comment)
+    {
+      Comment = comment;
+    }
+
+    [CanBeNull] public string Comment { get; }
+  }
+
+  /// <summary>
+  /// Tells the code analysis engine if the parameter is completely handled when the invoked method is on stack.
+  /// If the parameter is a delegate, indicates that delegate can only be invoked during method execution
+  /// (the delegate can be invoked zero or multiple times, but not stored to some field and invoked later,
+  /// when the containing method is no longer on the execution stack).
+  /// If the parameter is an enumerable, indicates that it is enumerated while the method is executed.
+  /// If <see cref="RequireAwait"/> is true, the attribute will only takes effect if the method invocation is located under the 'await' expression.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter)]
+  public sealed class InstantHandleAttribute : Attribute
+  {
+    /// <summary>
+    /// Require the method invocation to be used under the 'await' expression for this attribute to take effect on code analysis engine.
+    /// Can be used for delegate/enumerable parameters of 'async' methods.
+    /// </summary>
+    public bool RequireAwait { get; set; }
+  }
+
+  /// <summary>
+  /// Indicates that a method does not make any observable state changes.
+  /// The same as <c>System.Diagnostics.Contracts.PureAttribute</c>.
+  /// </summary>
+  /// <example><code>
+  /// [Pure] int Multiply(int x, int y) => x * y;
+  /// 
+  /// void M() {
+  ///   Multiply(123, 42); // Warning: Return value of pure method is not used
+  /// }
+  /// </code></example>
+  [AttributeUsage(AttributeTargets.Method)]
+  public sealed class PureAttribute : Attribute { }
+
+  /// <summary>
+  /// Indicates that the return value of the method invocation must be used.
+  /// </summary>
+  /// <remarks>
+  /// Methods decorated with this attribute (in contrast to pure methods) might change state,
+  /// but make no sense without using their return value. <br/>
+  /// Similarly to <see cref="PureAttribute"/>, this attribute
+  /// will help to detect usages of the method when the return value is not used.
+  /// Optionally, you can specify a message to use when showing warnings, e.g.
+  /// <code>[MustUseReturnValue("Use the return value to...")]</code>.
+  /// </remarks>
+  [AttributeUsage(AttributeTargets.Method)]
+  public sealed class MustUseReturnValueAttribute : Attribute
+  {
+    public MustUseReturnValueAttribute() { }
+
+    public MustUseReturnValueAttribute([NotNull] string justification)
+    {
+      Justification = justification;
+    }
+
+    [CanBeNull] public string Justification { get; }
+  }
+
+  /// <summary>
+  /// This annotation allows to enforce allocation-less usage patterns of delegates for performance-critical APIs.
+  /// When this annotation is applied to the parameter of delegate type, IDE checks the input argument of this parameter:
+  /// * When lambda expression or anonymous method is passed as an argument, IDE verifies that the passed closure
+  ///   has no captures of the containing local variables and the compiler is able to cache the delegate instance
+  ///   to avoid heap allocations. Otherwise the warning is produced.
+  /// * IDE warns when method name or local function name is passed as an argument as this always results
+  ///   in heap allocation of the delegate instance.
+  /// </summary>
+  /// <remarks>
+  /// In C# 9.0 code IDE would also suggest to annotate the anonymous function with 'static' modifier
+  /// to make use of the similar analysis provided by the language/compiler.
+  /// </remarks>
+  [AttributeUsage(AttributeTargets.Parameter)]
+  public class RequireStaticDelegateAttribute : Attribute
+  {
+    public bool IsError { get; set; }
+  }
+
+  /// <summary>
+  /// Indicates the type member or parameter of some type, that should be used instead of all other ways
+  /// to get the value of that type. This annotation is useful when you have some "context" value evaluated
+  /// and stored somewhere, meaning that all other ways to get this value must be consolidated with existing one.
+  /// </summary>
+  /// <example><code>
+  /// class Foo {
+  ///   [ProvidesContext] IBarService _barService = ...;
+  /// 
+  ///   void ProcessNode(INode node) {
+  ///     DoSomething(node, node.GetGlobalServices().Bar);
+  ///     //              ^ Warning: use value of '_barService' field
+  ///   }
+  /// }
+  /// </code></example>
+  [AttributeUsage(
+    AttributeTargets.Field | AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.Method |
+    AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.Struct | AttributeTargets.GenericParameter)]
+  public sealed class ProvidesContextAttribute : Attribute { }
+
+  /// <summary>
+  /// Indicates that a parameter is a path to a file or a folder within a web project.
+  /// Path can be relative or absolute, starting from web root (~).
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter)]
+  public sealed class PathReferenceAttribute : Attribute
+  {
+    public PathReferenceAttribute() { }
+
+    public PathReferenceAttribute([NotNull, PathReference] string basePath)
+    {
+      BasePath = basePath;
+    }
+
+    [CanBeNull] public string BasePath { get; }
+  }
+
+  /// <summary>
+  /// An extension method marked with this attribute is processed by code completion
+  /// as a 'Source Template'. When the extension method is completed over some expression, its source code
+  /// is automatically expanded like a template at call site.
+  /// </summary>
+  /// <remarks>
+  /// Template method body can contain valid source code and/or special comments starting with '$'.
+  /// Text inside these comments is added as source code when the template is applied. Template parameters
+  /// can be used either as additional method parameters or as identifiers wrapped in two '$' signs.
+  /// Use the <see cref="MacroAttribute"/> attribute to specify macros for parameters.
+  /// </remarks>
+  /// <example>
+  /// In this example, the 'forEach' method is a source template available over all values
+  /// of enumerable types, producing ordinary C# 'foreach' statement and placing caret inside block:
+  /// <code>
+  /// [SourceTemplate]
+  /// public static void forEach&lt;T&gt;(this IEnumerable&lt;T&gt; xs) {
+  ///   foreach (var x in xs) {
+  ///      //$ $END$
+  ///   }
+  /// }
+  /// </code>
+  /// </example>
+  [AttributeUsage(AttributeTargets.Method)]
+  public sealed class SourceTemplateAttribute : Attribute { }
+
+  /// <summary>
+  /// Allows specifying a macro for a parameter of a <see cref="SourceTemplateAttribute">source template</see>.
+  /// </summary>
+  /// <remarks>
+  /// You can apply the attribute on the whole method or on any of its additional parameters. The macro expression
+  /// is defined in the <see cref="MacroAttribute.Expression"/> property. When applied on a method, the target
+  /// template parameter is defined in the <see cref="MacroAttribute.Target"/> property. To apply the macro silently
+  /// for the parameter, set the <see cref="MacroAttribute.Editable"/> property value = -1.
+  /// </remarks>
+  /// <example>
+  /// Applying the attribute on a source template method:
+  /// <code>
+  /// [SourceTemplate, Macro(Target = "item", Expression = "suggestVariableName()")]
+  /// public static void forEach&lt;T&gt;(this IEnumerable&lt;T&gt; collection) {
+  ///   foreach (var item in collection) {
+  ///     //$ $END$
+  ///   }
+  /// }
+  /// </code>
+  /// Applying the attribute on a template method parameter:
+  /// <code>
+  /// [SourceTemplate]
+  /// public static void something(this Entity x, [Macro(Expression = "guid()", Editable = -1)] string newguid) {
+  ///   /*$ var $x$Id = "$newguid$" + x.ToString();
+  ///   x.DoSomething($x$Id); */
+  /// }
+  /// </code>
+  /// </example>
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method, AllowMultiple = true)]
+  public sealed class MacroAttribute : Attribute
+  {
+    /// <summary>
+    /// Allows specifying a macro that will be executed for a <see cref="SourceTemplateAttribute">source template</see>
+    /// parameter when the template is expanded.
+    /// </summary>
+    [CanBeNull] public string Expression { get; set; }
+
+    /// <summary>
+    /// Allows specifying which occurrence of the target parameter becomes editable when the template is deployed.
+    /// </summary>
+    /// <remarks>
+    /// If the target parameter is used several times in the template, only one occurrence becomes editable;
+    /// other occurrences are changed synchronously. To specify the zero-based index of the editable occurrence,
+    /// use values >= 0. To make the parameter non-editable when the template is expanded, use -1.
+    /// </remarks>
+    public int Editable { get; set; }
+
+    /// <summary>
+    /// Identifies the target parameter of a <see cref="SourceTemplateAttribute">source template</see> if the
+    /// <see cref="MacroAttribute"/> is applied on a template method.
+    /// </summary>
+    [CanBeNull] public string Target { get; set; }
+  }
+
+  [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = true)]
+  public sealed class AspMvcAreaMasterLocationFormatAttribute : Attribute
+  {
+    public AspMvcAreaMasterLocationFormatAttribute([NotNull] string format)
+    {
+      Format = format;
+    }
+
+    [NotNull] public string Format { get; }
+  }
+
+  [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = true)]
+  public sealed class AspMvcAreaPartialViewLocationFormatAttribute : Attribute
+  {
+    public AspMvcAreaPartialViewLocationFormatAttribute([NotNull] string format)
+    {
+      Format = format;
+    }
+
+    [NotNull] public string Format { get; }
+  }
+
+  [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = true)]
+  public sealed class AspMvcAreaViewLocationFormatAttribute : Attribute
+  {
+    public AspMvcAreaViewLocationFormatAttribute([NotNull] string format)
+    {
+      Format = format;
+    }
+
+    [NotNull] public string Format { get; }
+  }
+
+  [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = true)]
+  public sealed class AspMvcMasterLocationFormatAttribute : Attribute
+  {
+    public AspMvcMasterLocationFormatAttribute([NotNull] string format)
+    {
+      Format = format;
+    }
+
+    [NotNull] public string Format { get; }
+  }
+
+  [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = true)]
+  public sealed class AspMvcPartialViewLocationFormatAttribute : Attribute
+  {
+    public AspMvcPartialViewLocationFormatAttribute([NotNull] string format)
+    {
+      Format = format;
+    }
+
+    [NotNull] public string Format { get; }
+  }
+
+  [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = true)]
+  public sealed class AspMvcViewLocationFormatAttribute : Attribute
+  {
+    public AspMvcViewLocationFormatAttribute([NotNull] string format)
+    {
+      Format = format;
+    }
+
+    [NotNull] public string Format { get; }
+  }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
+  /// is an MVC action. If applied to a method, the MVC action name is calculated
+  /// implicitly from the context. Use this attribute for custom wrappers similar to
+  /// <c>System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String)</c>.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)]
+  public sealed class AspMvcActionAttribute : Attribute
+  {
+    public AspMvcActionAttribute() { }
+
+    public AspMvcActionAttribute([NotNull] string anonymousProperty)
+    {
+      AnonymousProperty = anonymousProperty;
+    }
+
+    [CanBeNull] public string AnonymousProperty { get; }
+  }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. Indicates that the marked parameter is an MVC area.
+  /// Use this attribute for custom wrappers similar to
+  /// <c>System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String)</c>.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
+  public sealed class AspMvcAreaAttribute : Attribute
+  {
+    public AspMvcAreaAttribute() { }
+
+    public AspMvcAreaAttribute([NotNull] string anonymousProperty)
+    {
+      AnonymousProperty = anonymousProperty;
+    }
+
+    [CanBeNull] public string AnonymousProperty { get; }
+  }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter is
+  /// an MVC controller. If applied to a method, the MVC controller name is calculated
+  /// implicitly from the context. Use this attribute for custom wrappers similar to
+  /// <c>System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String, String)</c>.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)]
+  public sealed class AspMvcControllerAttribute : Attribute
+  {
+    public AspMvcControllerAttribute() { }
+
+    public AspMvcControllerAttribute([NotNull] string anonymousProperty)
+    {
+      AnonymousProperty = anonymousProperty;
+    }
+
+    [CanBeNull] public string AnonymousProperty { get; }
+  }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. Indicates that the marked parameter is an MVC Master. Use this attribute
+  /// for custom wrappers similar to <c>System.Web.Mvc.Controller.View(String, String)</c>.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
+  public sealed class AspMvcMasterAttribute : Attribute { }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. Indicates that the marked parameter is an MVC model type. Use this attribute
+  /// for custom wrappers similar to <c>System.Web.Mvc.Controller.View(String, Object)</c>.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter)]
+  public sealed class AspMvcModelTypeAttribute : Attribute { }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter is an MVC
+  /// partial view. If applied to a method, the MVC partial view name is calculated implicitly
+  /// from the context. Use this attribute for custom wrappers similar to
+  /// <c>System.Web.Mvc.Html.RenderPartialExtensions.RenderPartial(HtmlHelper, String)</c>.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)]
+  public sealed class AspMvcPartialViewAttribute : Attribute { }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. Allows disabling inspections for MVC views within a class or a method.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
+  public sealed class AspMvcSuppressViewErrorAttribute : Attribute { }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. Indicates that a parameter is an MVC display template.
+  /// Use this attribute for custom wrappers similar to
+  /// <c>System.Web.Mvc.Html.DisplayExtensions.DisplayForModel(HtmlHelper, String)</c>.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
+  public sealed class AspMvcDisplayTemplateAttribute : Attribute { }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. Indicates that the marked parameter is an MVC editor template.
+  /// Use this attribute for custom wrappers similar to
+  /// <c>System.Web.Mvc.Html.EditorExtensions.EditorForModel(HtmlHelper, String)</c>.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
+  public sealed class AspMvcEditorTemplateAttribute : Attribute { }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. Indicates that the marked parameter is an MVC template.
+  /// Use this attribute for custom wrappers similar to
+  /// <c>System.ComponentModel.DataAnnotations.UIHintAttribute(System.String)</c>.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
+  public sealed class AspMvcTemplateAttribute : Attribute { }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
+  /// is an MVC view component. If applied to a method, the MVC view name is calculated implicitly
+  /// from the context. Use this attribute for custom wrappers similar to
+  /// <c>System.Web.Mvc.Controller.View(Object)</c>.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)]
+  public sealed class AspMvcViewAttribute : Attribute { }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
+  /// is an MVC view component name.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
+  public sealed class AspMvcViewComponentAttribute : Attribute { }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
+  /// is an MVC view component view. If applied to a method, the MVC view component view name is default.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)]
+  public sealed class AspMvcViewComponentViewAttribute : Attribute { }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. When applied to a parameter of an attribute,
+  /// indicates that this parameter is an MVC action name.
+  /// </summary>
+  /// <example><code>
+  /// [ActionName("Foo")]
+  /// public ActionResult Login(string returnUrl) {
+  ///   ViewBag.ReturnUrl = Url.Action("Foo"); // OK
+  ///   return RedirectToAction("Bar"); // Error: Cannot resolve action
+  /// }
+  /// </code></example>
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property)]
+  public sealed class AspMvcActionSelectorAttribute : Attribute { }
+
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.Field)]
+  public sealed class HtmlElementAttributesAttribute : Attribute
+  {
+    public HtmlElementAttributesAttribute() { }
+
+    public HtmlElementAttributesAttribute([NotNull] string name)
+    {
+      Name = name;
+    }
+
+    [CanBeNull] public string Name { get; }
+  }
+
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
+  public sealed class HtmlAttributeValueAttribute : Attribute
+  {
+    public HtmlAttributeValueAttribute([NotNull] string name)
+    {
+      Name = name;
+    }
+
+    [NotNull] public string Name { get; }
+  }
+
+  /// <summary>
+  /// Razor attribute. Indicates that the marked parameter or method is a Razor section.
+  /// Use this attribute for custom wrappers similar to
+  /// <c>System.Web.WebPages.WebPageBase.RenderSection(String)</c>.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)]
+  public sealed class RazorSectionAttribute : Attribute { }
+
+  /// <summary>
+  /// Indicates how method, constructor invocation, or property access
+  /// over collection type affects the contents of the collection.
+  /// When applied to a return value of a method indicates if the returned collection
+  /// is created exclusively for the caller (CollectionAccessType.UpdatedContent) or
+  /// can be read/updated from outside (CollectionAccessType.Read | CollectionAccessType.UpdatedContent)
+  /// Use <see cref="CollectionAccessType"/> to specify the access type.
+  /// </summary>
+  /// <remarks>
+  /// Using this attribute only makes sense if all collection methods are marked with this attribute.
+  /// </remarks>
+  /// <example><code>
+  /// public class MyStringCollection : List&lt;string&gt;
+  /// {
+  ///   [CollectionAccess(CollectionAccessType.Read)]
+  ///   public string GetFirstString()
+  ///   {
+  ///     return this.ElementAt(0);
+  ///   }
+  /// }
+  /// class Test
+  /// {
+  ///   public void Foo()
+  ///   {
+  ///     // Warning: Contents of the collection is never updated
+  ///     var col = new MyStringCollection();
+  ///     string x = col.GetFirstString();
+  ///   }
+  /// }
+  /// </code></example>
+  [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Property | AttributeTargets.ReturnValue)]
+  public sealed class CollectionAccessAttribute : Attribute
+  {
+    public CollectionAccessAttribute(CollectionAccessType collectionAccessType)
+    {
+      CollectionAccessType = collectionAccessType;
+    }
+
+    public CollectionAccessType CollectionAccessType { get; }
+  }
+
+  /// <summary>
+  /// Provides a value for the <see cref="CollectionAccessAttribute"/> to define
+  /// how the collection method invocation affects the contents of the collection.
+  /// </summary>
+  [Flags]
+  public enum CollectionAccessType
+  {
+    /// <summary>Method does not use or modify content of the collection.</summary>
+    None = 0,
+    /// <summary>Method only reads content of the collection but does not modify it.</summary>
+    Read = 1,
+    /// <summary>Method can change content of the collection but does not add new elements.</summary>
+    ModifyExistingContent = 2,
+    /// <summary>Method can add new elements to the collection.</summary>
+    UpdatedContent = ModifyExistingContent | 4
+  }
+
+  /// <summary>
+  /// Indicates that the marked method is assertion method, i.e. it halts the control flow if
+  /// one of the conditions is satisfied. To set the condition, mark one of the parameters with
+  /// <see cref="AssertionConditionAttribute"/> attribute.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Method)]
+  public sealed class AssertionMethodAttribute : Attribute { }
+
+  /// <summary>
+  /// Indicates the condition parameter of the assertion method. The method itself should be
+  /// marked by <see cref="AssertionMethodAttribute"/> attribute. The mandatory argument of
+  /// the attribute is the assertion type.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter)]
+  public sealed class AssertionConditionAttribute : Attribute
+  {
+    public AssertionConditionAttribute(AssertionConditionType conditionType)
+    {
+      ConditionType = conditionType;
+    }
+
+    public AssertionConditionType ConditionType { get; }
+  }
+
+  /// <summary>
+  /// Specifies assertion type. If the assertion method argument satisfies the condition,
+  /// then the execution continues. Otherwise, execution is assumed to be halted.
+  /// </summary>
+  public enum AssertionConditionType
+  {
+    /// <summary>Marked parameter should be evaluated to true.</summary>
+    IS_TRUE = 0,
+    /// <summary>Marked parameter should be evaluated to false.</summary>
+    IS_FALSE = 1,
+    /// <summary>Marked parameter should be evaluated to null value.</summary>
+    IS_NULL = 2,
+    /// <summary>Marked parameter should be evaluated to not null value.</summary>
+    IS_NOT_NULL = 3,
+  }
+
+  /// <summary>
+  /// Indicates that the marked method unconditionally terminates control flow execution.
+  /// For example, it could unconditionally throw exception.
+  /// </summary>
+  [Obsolete("Use [ContractAnnotation('=> halt')] instead")]
+  [AttributeUsage(AttributeTargets.Method)]
+  public sealed class TerminatesProgramAttribute : Attribute { }
+
+  /// <summary>
+  /// Indicates that the method is a pure LINQ method, with postponed enumeration (like Enumerable.Select,
+  /// .Where). This annotation allows inference of [InstantHandle] annotation for parameters
+  /// of delegate type by analyzing LINQ method chains.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Method)]
+  public sealed class LinqTunnelAttribute : Attribute { }
+
+  /// <summary>
+  /// Indicates that IEnumerable passed as a parameter is not enumerated.
+  /// Use this annotation to suppress the 'Possible multiple enumeration of IEnumerable' inspection.
+  /// </summary>
+  /// <example><code>
+  /// static void ThrowIfNull&lt;T&gt;([NoEnumeration] T v, string n) where T : class
+  /// {
+  ///   // custom check for null but no enumeration
+  /// }
+  /// 
+  /// void Foo(IEnumerable&lt;string&gt; values)
+  /// {
+  ///   ThrowIfNull(values, nameof(values));
+  ///   var x = values.ToList(); // No warnings about multiple enumeration
+  /// }
+  /// </code></example>
+  [AttributeUsage(AttributeTargets.Parameter)]
+  public sealed class NoEnumerationAttribute : Attribute { }
+
+  /// <summary>
+  /// Indicates that the marked parameter, field, or property is a regular expression pattern.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
+  public sealed class RegexPatternAttribute : Attribute { }
+
+  /// <summary>
+  /// Language of injected code fragment inside marked by <see cref="LanguageInjectionAttribute"/> string literal.
+  /// </summary>
+  public enum InjectedLanguage
+  {
+    CSS,
+    HTML,
+    JAVASCRIPT,
+    JSON,
+    XML
+  }
+
+  /// <summary>
+  /// Indicates that the marked parameter, field, or property is accepting a string literal
+  /// containing code fragment in a language specified by the <see cref="InjectedLanguage"/>.
+  /// </summary>
+  /// <example><code>
+  /// void Foo([LanguageInjection(InjectedLanguage.CSS, Prefix = "body{", Suffix = "}")] string cssProps)
+  /// {
+  ///   // cssProps should only contains a list of CSS properties
+  /// }
+  /// </code></example>
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
+  public sealed class LanguageInjectionAttribute : Attribute
+  {
+    public LanguageInjectionAttribute(InjectedLanguage injectedLanguage)
+    {
+      InjectedLanguage = injectedLanguage;
+    }
+
+    /// <summary>Specify a language of injected code fragment.</summary>
+    public InjectedLanguage InjectedLanguage { get; }
+    /// <summary>Specify a string that "precedes" injected string literal.</summary>
+    [CanBeNull] public string Prefix { get; set; }
+    /// <summary>Specify a string that "follows" injected string literal.</summary>
+    [CanBeNull] public string Suffix { get; set; }
+  }
+
+  /// <summary>
+  /// Prevents the Member Reordering feature from tossing members of the marked class.
+  /// </summary>
+  /// <remarks>
+  /// The attribute must be mentioned in your member reordering patterns.
+  /// </remarks>
+  [AttributeUsage(
+    AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.Struct | AttributeTargets.Enum)]
+  public sealed class NoReorderAttribute : Attribute { }
+
+  /// <summary>
+  /// XAML attribute. Indicates the type that has <c>ItemsSource</c> property and should be treated
+  /// as <c>ItemsControl</c>-derived type, to enable inner items <c>DataContext</c> type resolve.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Class)]
+  public sealed class XamlItemsControlAttribute : Attribute { }
+
+  /// <summary>
+  /// XAML attribute. Indicates the property of some <c>BindingBase</c>-derived type, that
+  /// is used to bind some item of <c>ItemsControl</c>-derived type. This annotation will
+  /// enable the <c>DataContext</c> type resolve for XAML bindings for such properties.
+  /// </summary>
+  /// <remarks>
+  /// Property should have the tree ancestor of the <c>ItemsControl</c> type or
+  /// marked with the <see cref="XamlItemsControlAttribute"/> attribute.
+  /// </remarks>
+  [AttributeUsage(AttributeTargets.Property)]
+  public sealed class XamlItemBindingOfItemsControlAttribute : Attribute { }
+
+  /// <summary>
+  /// XAML attribute. Indicates the property of some <c>Style</c>-derived type, that
+  /// is used to style items of <c>ItemsControl</c>-derived type. This annotation will
+  /// enable the <c>DataContext</c> type resolve for XAML bindings for such properties.
+  /// </summary>
+  /// <remarks>
+  /// Property should have the tree ancestor of the <c>ItemsControl</c> type or
+  /// marked with the <see cref="XamlItemsControlAttribute"/> attribute.
+  /// </remarks>
+  [AttributeUsage(AttributeTargets.Property)]
+  public sealed class XamlItemStyleOfItemsControlAttribute : Attribute { }
+
+  /// <summary>
+  /// XAML attribute. Indicates that DependencyProperty has <c>OneWay</c> binding mode by default.
+  /// </summary>
+  /// <remarks>
+  /// This attribute must be applied to DependencyProperty's CLR accessor property if it is present, to DependencyProperty descriptor field otherwise.
+  /// </remarks>
+  [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
+  public sealed class XamlOneWayBindingModeByDefaultAttribute : Attribute { }
+
+  /// <summary>
+  /// XAML attribute. Indicates that DependencyProperty has <c>TwoWay</c> binding mode by default.
+  /// </summary>
+  /// <remarks>
+  /// This attribute must be applied to DependencyProperty's CLR accessor property if it is present, to DependencyProperty descriptor field otherwise.
+  /// </remarks>
+  [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
+  public sealed class XamlTwoWayBindingModeByDefaultAttribute : Attribute { }
+
+  [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
+  public sealed class AspChildControlTypeAttribute : Attribute
+  {
+    public AspChildControlTypeAttribute([NotNull] string tagName, [NotNull] Type controlType)
+    {
+      TagName = tagName;
+      ControlType = controlType;
+    }
+
+    [NotNull] public string TagName { get; }
+
+    [NotNull] public Type ControlType { get; }
+  }
+
+  [AttributeUsage(AttributeTargets.Property | AttributeTargets.Method)]
+  public sealed class AspDataFieldAttribute : Attribute { }
+
+  [AttributeUsage(AttributeTargets.Property | AttributeTargets.Method)]
+  public sealed class AspDataFieldsAttribute : Attribute { }
+
+  [AttributeUsage(AttributeTargets.Property)]
+  public sealed class AspMethodPropertyAttribute : Attribute { }
+
+  [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
+  public sealed class AspRequiredAttributeAttribute : Attribute
+  {
+    public AspRequiredAttributeAttribute([NotNull] string attribute)
+    {
+      Attribute = attribute;
+    }
+
+    [NotNull] public string Attribute { get; }
+  }
+
+  [AttributeUsage(AttributeTargets.Property)]
+  public sealed class AspTypePropertyAttribute : Attribute
+  {
+    public bool CreateConstructorReferences { get; }
+
+    public AspTypePropertyAttribute(bool createConstructorReferences)
+    {
+      CreateConstructorReferences = createConstructorReferences;
+    }
+  }
+
+  [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+  public sealed class RazorImportNamespaceAttribute : Attribute
+  {
+    public RazorImportNamespaceAttribute([NotNull] string name)
+    {
+      Name = name;
+    }
+
+    [NotNull] public string Name { get; }
+  }
+
+  [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+  public sealed class RazorInjectionAttribute : Attribute
+  {
+    public RazorInjectionAttribute([NotNull] string type, [NotNull] string fieldName)
+    {
+      Type = type;
+      FieldName = fieldName;
+    }
+
+    [NotNull] public string Type { get; }
+
+    [NotNull] public string FieldName { get; }
+  }
+
+  [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+  public sealed class RazorDirectiveAttribute : Attribute
+  {
+    public RazorDirectiveAttribute([NotNull] string directive)
+    {
+      Directive = directive;
+    }
+
+    [NotNull] public string Directive { get; }
+  }
+
+  [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+  public sealed class RazorPageBaseTypeAttribute : Attribute
+  {
+      public RazorPageBaseTypeAttribute([NotNull] string baseType)
+      {
+        BaseType = baseType;
+      }
+      public RazorPageBaseTypeAttribute([NotNull] string baseType, string pageName)
+      {
+          BaseType = baseType;
+          PageName = pageName;
+      }
+
+      [NotNull] public string BaseType { get; }
+      [CanBeNull] public string PageName { get; }
+  }
+
+  [AttributeUsage(AttributeTargets.Method)]
+  public sealed class RazorHelperCommonAttribute : Attribute { }
+
+  [AttributeUsage(AttributeTargets.Property)]
+  public sealed class RazorLayoutAttribute : Attribute { }
+
+  [AttributeUsage(AttributeTargets.Method)]
+  public sealed class RazorWriteLiteralMethodAttribute : Attribute { }
+
+  [AttributeUsage(AttributeTargets.Method)]
+  public sealed class RazorWriteMethodAttribute : Attribute { }
+
+  [AttributeUsage(AttributeTargets.Parameter)]
+  public sealed class RazorWriteMethodParameterAttribute : Attribute { }
+
+  /// <summary>
+  /// Indicates that the marked parameter, field, or property is a route template.
+  /// </summary>
+  /// <remarks>
+  /// This attribute allows IDE to recognize the use of web frameworks' route templates
+  /// to enable syntax highlighting, code completion, navigation, rename and other features in string literals.
+  /// </remarks>
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
+  public sealed class RouteTemplateAttribute : Attribute { }
+
+  /// <summary>
+  /// Indicates that the marked type is custom route parameter constraint,
+  /// which is registered in application's Startup with name <c>ConstraintName</c>
+  /// </summary>
+  /// <remarks>
+  /// You can specify <c>ProposedType</c> if target constraint matches only route parameters of specific type,
+  /// it will allow IDE to create method's parameter from usage in route template
+  /// with specified type instead of default <c>System.String</c>
+  /// and check if constraint's proposed type conflicts with matched parameter's type
+  /// </remarks>
+  [AttributeUsage(AttributeTargets.Class)]
+  public sealed class RouteParameterConstraintAttribute : Attribute
+  {
+    [NotNull] public string ConstraintName { get; }
+    [CanBeNull] public Type ProposedType { get; set; }
+
+    public RouteParameterConstraintAttribute([NotNull] string constraintName)
+    {
+      ConstraintName = constraintName;
+    }
+  }
+
+  /// <summary>
+  /// Indicates that the marked parameter, field, or property is an URI string.
+  /// </summary>
+  /// <remarks>
+  /// This attribute enables code completion, navigation, rename and other features
+  /// in URI string literals assigned to annotated parameter, field or property.
+  /// </remarks>
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
+  public sealed class UriStringAttribute : Attribute
+  {
+    public UriStringAttribute() { }
+
+    public UriStringAttribute(string httpVerb)
+    {
+      HttpVerb = httpVerb;
+    }
+
+    [CanBeNull] public string HttpVerb { get; }
+  }
+
+  /// <summary>
+  /// <para>
+  /// Defines the code search template using the Structural Search and Replace syntax.
+  /// It allows you to find and, if necessary, replace blocks of code that match a specific pattern.
+  /// Search and replace patterns consist of a textual part and placeholders.
+  /// Textural part must contain only identifiers allowed in the target language and will be matched exactly (white spaces, tabulation characters, and line breaks are ignored).
+  /// Placeholders allow matching variable parts of the target code blocks.
+  /// A placeholder has the following format: $placeholder_name$- where placeholder_name is an arbitrary identifier.
+  /// </para>
+  /// <para>
+  /// Available placeholders:
+  /// <list type="bullet">
+  /// <item>$this$ - expression of containing type</item>
+  /// <item>$thisType$ - containing type</item>
+  /// <item>$member$ - current member placeholder</item>
+  /// <item>$qualifier$ - this placeholder is available in the replace pattern and can be used to insert qualifier expression matched by the $member$ placeholder.
+  /// (Note that if $qualifier$ placeholder is used, then $member$ placeholder will match only qualified references)</item>
+  /// <item>$expression$ - expression of any type</item>
+  /// <item>$identifier$ - identifier placeholder</item>
+  /// <item>$args$ - any number of arguments</item>
+  /// <item>$arg$ - single argument</item>
+  /// <item>$arg1$ ... $arg10$ - single argument</item>
+  /// <item>$stmts$ - any number of statements</item>
+  /// <item>$stmt$ - single statement</item>
+  /// <item>$stmt1$ ... $stmt10$ - single statement</item>
+  /// <item>$name{Expression, 'Namespace.FooType'}$ - expression with 'Namespace.FooType' type</item>
+  /// <item>$expression{'Namespace.FooType'}$ - expression with 'Namespace.FooType' type</item>
+  /// <item>$name{Type, 'Namespace.FooType'}$ - 'Namespace.FooType' type</item>
+  /// <item>$type{'Namespace.FooType'}$ - 'Namespace.FooType' type</item>
+  /// <item>$statement{1,2}$ - 1 or 2 statements</item>
+  /// </list>
+  /// </para>
+  /// <para>
+  /// Note that you can also define your own placeholders of the supported types and specify arguments for each placeholder type.
+  /// This can be done using the following format: $name{type, arguments}$. Where 'name' - is the name of your placeholder,
+  /// 'type' - is the type of your placeholder (one of the following: Expression, Type, Identifier, Statement, Argument, Member),
+  /// 'arguments' - arguments list for your placeholder. Each placeholder type supports it's own arguments, check examples below for mode details.
+  /// Placeholder type may be omitted and determined from the placeholder name, if name has one of the following prefixes:
+  /// <list type="bullet">
+  /// <item>expr, expression - expression placeholder, e.g. $exprPlaceholder{}$, $expressionFoo{}$</item>
+  /// <item>arg, argument - argument placeholder, e.g. $argPlaceholder{}$, $argumentFoo{}$</item>
+  /// <item>ident, identifier - identifier placeholder, e.g. $identPlaceholder{}$, $identifierFoo{}$</item>
+  /// <item>stmt, statement - statement placeholder, e.g. $stmtPlaceholder{}$, $statementFoo{}$</item>
+  /// <item>type - type placeholder, e.g. $typePlaceholder{}$, $typeFoo{}$</item>
+  /// <item>member - member placeholder, e.g. $memberPlaceholder{}$, $memberFoo{}$</item>
+  /// </list>
+  /// </para>
+  /// <para>
+  /// Expression placeholder arguments:
+  /// <list type="bullet">
+  /// <item>expressionType - string value in single quotes, specifies full type name to match (empty string by default)</item>
+  /// <item>exactType - boolean value, specifies if expression should have exact type match (false by default)</item>
+  /// </list>
+  /// Examples:
+  /// <list type="bullet">
+  /// <item>$myExpr{Expression, 'Namespace.FooType', true}$ - defines expression placeholder, matching expressions of the 'Namespace.FooType' type with exact matching.</item>
+  /// <item>$myExpr{Expression, 'Namespace.FooType'}$ - defines expression placeholder, matching expressions of the 'Namespace.FooType' type or expressions which can be implicitly converted to 'Namespace.FooType'.</item>
+  /// <item>$myExpr{Expression}$ - defines expression placeholder, matching expressions of any type.</item>
+  /// <item>$exprFoo{'Namespace.FooType', true}$ - defines expression placeholder, matching expressions of the 'Namespace.FooType' type with exact matching.</item>
+  /// </list>
+  /// </para>
+  /// <para>
+  /// Type placeholder arguments:
+  /// <list type="bullet">
+  /// <item>type - string value in single quotes, specifies full type name to match (empty string by default)</item>
+  /// <item>exactType - boolean value, specifies if expression should have exact type match (false by default)</item>
+  /// </list>
+  /// Examples:
+  /// <list type="bullet">
+  /// <item>$myType{Type, 'Namespace.FooType', true}$ - defines type placeholder, matching 'Namespace.FooType' types with exact matching.</item>
+  /// <item>$myType{Type, 'Namespace.FooType'}$ - defines type placeholder, matching 'Namespace.FooType' types or types, which can be implicitly converted to 'Namespace.FooType'.</item>
+  /// <item>$myType{Type}$ - defines type placeholder, matching any type.</item>
+  /// <item>$typeFoo{'Namespace.FooType', true}$ - defines types placeholder, matching 'Namespace.FooType' types with exact matching.</item>
+  /// </list>
+  /// </para>
+  /// <para>
+  /// Identifier placeholder arguments:
+  /// <list type="bullet">
+  /// <item>nameRegex - string value in single quotes, specifies regex to use for matching (empty string by default)</item>
+  /// <item>nameRegexCaseSensitive - boolean value, specifies if name regex is case sensitive (true by default)</item>
+  /// <item>type - string value in single quotes, specifies full type name to match (empty string by default)</item>
+  /// <item>exactType - boolean value, specifies if expression should have exact type match (false by default)</item>
+  /// </list>
+  /// Examples:
+  /// <list type="bullet">
+  /// <item>$myIdentifier{Identifier, 'my.*', false, 'Namespace.FooType', true}$ - defines identifier placeholder, matching identifiers (ignoring case) starting with 'my' prefix with 'Namespace.FooType' type.</item>
+  /// <item>$myIdentifier{Identifier, 'my.*', true, 'Namespace.FooType', true}$ - defines identifier placeholder, matching identifiers (case sensitively) starting with 'my' prefix with 'Namespace.FooType' type.</item>
+  /// <item>$identFoo{'my.*'}$ - defines identifier placeholder, matching identifiers (case sensitively) starting with 'my' prefix.</item>
+  /// </list>
+  /// </para>
+  /// <para>
+  /// Statement placeholder arguments:
+  /// <list type="bullet">
+  /// <item>minimalOccurrences - minimal number of statements to match (-1 by default)</item>
+  /// <item>maximalOccurrences - maximal number of statements to match (-1 by default)</item>
+  /// </list>
+  /// Examples:
+  /// <list type="bullet">
+  /// <item>$myStmt{Statement, 1, 2}$ - defines statement placeholder, matching 1 or 2 statements.</item>
+  /// <item>$myStmt{Statement}$ - defines statement placeholder, matching any number of statements.</item>
+  /// <item>$stmtFoo{1, 2}$ - defines statement placeholder, matching 1 or 2 statements.</item>
+  /// </list>
+  /// </para>
+  /// <para>
+  /// Argument placeholder arguments:
+  /// <list type="bullet">
+  /// <item>minimalOccurrences - minimal number of arguments to match (-1 by default)</item>
+  /// <item>maximalOccurrences - maximal number of arguments to match (-1 by default)</item>
+  /// </list>
+  /// Examples:
+  /// <list type="bullet">
+  /// <item>$myArg{Argument, 1, 2}$ - defines argument placeholder, matching 1 or 2 arguments.</item>
+  /// <item>$myArg{Argument}$ - defines argument placeholder, matching any number of arguments.</item>
+  /// <item>$argFoo{1, 2}$ - defines argument placeholder, matching 1 or 2 arguments.</item>
+  /// </list>
+  /// </para>
+  /// <para>
+  /// Member placeholder arguments:
+  /// <list type="bullet">
+  /// <item>docId - string value in single quotes, specifies XML documentation id of the member to match (empty by default)</item>
+  /// </list>
+  /// Examples:
+  /// <list type="bullet">
+  /// <item>$myMember{Member, 'M:System.String.IsNullOrEmpty(System.String)'}$ - defines member placeholder, matching 'IsNullOrEmpty' member of the 'System.String' type.</item>
+  /// <item>$memberFoo{'M:System.String.IsNullOrEmpty(System.String)'}$ - defines member placeholder, matching 'IsNullOrEmpty' member of the 'System.String' type.</item>
+  /// </list>
+  /// </para>
+  /// <para>
+  /// For more information please refer to the <a href="https://www.jetbrains.com/help/resharper/Navigation_and_Search__Structural_Search_and_Replace.html">Structural Search and Replace</a> article.
+  /// </para>
+  /// </summary>
+  [AttributeUsage(
+    AttributeTargets.Method
+    | AttributeTargets.Constructor
+    | AttributeTargets.Property
+    | AttributeTargets.Field
+    | AttributeTargets.Event
+    | AttributeTargets.Interface
+    | AttributeTargets.Class
+    | AttributeTargets.Struct
+    | AttributeTargets.Enum,
+    AllowMultiple = true,
+    Inherited = false)]
+  public sealed class CodeTemplateAttribute : Attribute
+  {
+    public CodeTemplateAttribute(string searchTemplate)
+    {
+      SearchTemplate = searchTemplate;
+    }
+
+    /// <summary>
+    /// Structural search pattern to use in the code template.
+    /// Pattern includes textual part, which must contain only identifiers allowed in the target language,
+    /// and placeholders, which allow matching variable parts of the target code blocks.
+    /// </summary>
+    public string SearchTemplate { get; }
+
+    /// <summary>
+    /// Message to show when the search pattern was found.
+    /// You can also prepend the message text with "Error:", "Warning:", "Suggestion:" or "Hint:" prefix to specify the pattern severity.
+    /// Code patterns with replace template produce suggestions by default.
+    /// However, if replace template is not provided, then warning severity will be used.
+    /// </summary>
+    public string Message { get; set; }
+
+    /// <summary>
+    /// Structural search replace pattern to use in code template replacement.
+    /// </summary>
+    public string ReplaceTemplate { get; set; }
+
+    /// <summary>
+    /// Replace message to show in the light bulb.
+    /// </summary>
+    public string ReplaceMessage { get; set; }
+
+    /// <summary>
+    /// Apply code formatting after code replacement.
+    /// </summary>
+    public bool FormatAfterReplace { get; set; } = true;
+
+    /// <summary>
+    /// Whether similar code blocks should be matched.
+    /// </summary>
+    public bool MatchSimilarConstructs { get; set; }
+
+    /// <summary>
+    /// Automatically insert namespace import directives or remove qualifiers that become redundant after the template is applied.
+    /// </summary>
+    public bool ShortenReferences { get; set; }
+
+    /// <summary>
+    /// String to use as a suppression key.
+    /// By default the following suppression key is used 'CodeTemplate_SomeType_SomeMember',
+    /// where 'SomeType' and 'SomeMember' are names of the associated containing type and member to which this attribute is applied.
+    /// </summary>
+    public string SuppressionKey { get; set; }
+  }
+}
diff --git a/Properties/AssemblyInfo.cs b/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..7fecb95
--- /dev/null
+++ b/Properties/AssemblyInfo.cs
@@ -0,0 +1,53 @@
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Windows;
+
+// Общие сведения об этой сборке предоставляются следующим набором
+// набор атрибутов. Измените значения этих атрибутов, чтобы изменить сведения,
+// связанные со сборкой.
+[assembly: AssemblyTitle("StructureHelper")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("StructureHelper")]
+[assembly: AssemblyCopyright("Copyright ©  2022")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Установка значения False для параметра ComVisible делает типы в этой сборке невидимыми
+// для компонентов COM. Если необходимо обратиться к типу в этой сборке через
+// из модели COM, установите атрибут ComVisible для этого типа в значение true.
+[assembly: ComVisible(false)]
+
+//Чтобы начать создание локализуемых приложений, задайте
+//<UICulture>CultureYouAreCodingWith</UICulture> в файле .csproj
+//в <PropertyGroup>. Например, при использовании английского (США)
+//в своих исходных файлах установите <UICulture> в en-US.  Затем отмените преобразование в комментарий
+//атрибута NeutralResourceLanguage ниже.  Обновите "en-US" в
+//строка внизу для обеспечения соответствия настройки UICulture в файле проекта.
+
+//[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)]
+
+
+[assembly: ThemeInfo(
+    ResourceDictionaryLocation.None, //где расположены словари ресурсов по конкретным тематикам
+                                     //(используется, если ресурс не найден на странице,
+                                     // или в словарях ресурсов приложения)
+    ResourceDictionaryLocation.SourceAssembly //где расположен словарь универсальных ресурсов
+                                              //(используется, если ресурс не найден на странице,
+                                              // в приложении или в каких-либо словарях ресурсов для конкретной темы)
+)]
+
+
+// Сведения о версии для сборки включают четыре следующих значения:
+//
+//      Основной номер версии
+//      Дополнительный номер версии
+//      Номер сборки
+//      Номер редакции
+//
+// Можно задать все значения или принять номера сборки и редакции по умолчанию 
+// используя "*", как показано ниже:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/StructureHelper.csproj b/StructureHelper.csproj
new file mode 100644
index 0000000..73e59fd
--- /dev/null
+++ b/StructureHelper.csproj
@@ -0,0 +1,133 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{BAD27E27-4444-4300-ADF8-E21042C0781D}</ProjectGuid>
+    <OutputType>WinExe</OutputType>
+    <RootNamespace>StructureHelper</RootNamespace>
+    <AssemblyName>StructureHelper</AssemblyName>
+    <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <ProjectTypeGuids>{60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <WarningLevel>4</WarningLevel>
+    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
+    <Deterministic>true</Deterministic>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Microsoft.Expression.Interactions, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>packages\System.Windows.Interactivity.WPF.2.0.20525\lib\net40\Microsoft.Expression.Interactions.dll</HintPath>
+    </Reference>
+    <Reference Include="Newtonsoft.Json, Version=12.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <HintPath>packages\Newtonsoft.Json.12.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Windows.Interactivity, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>packages\System.Windows.Interactivity.WPF.2.0.20525\lib\net40\System.Windows.Interactivity.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Xml" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xaml">
+      <RequiredTargetFramework>4.0</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="WindowsBase" />
+    <Reference Include="PresentationCore" />
+    <Reference Include="PresentationFramework" />
+  </ItemGroup>
+  <ItemGroup>
+    <ApplicationDefinition Include="App.xaml">
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+    </ApplicationDefinition>
+    <Compile Include="Windows\AddMaterialWindow\AddMaterialView.xaml.cs">
+      <DependentUpon>AddMaterialView.xaml</DependentUpon>
+    </Compile>
+    <Compile Include="Windows\AddMaterialWindow\AddMaterialViewModel.cs" />
+    <Compile Include="App.xaml.cs">
+      <DependentUpon>App.xaml</DependentUpon>
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Windows\ColorPickerWindow\ColorPickerView.xaml.cs">
+      <DependentUpon>ColorPickerView.xaml</DependentUpon>
+    </Compile>
+    <Compile Include="Windows\ColorPickerWindow\ColorPickerViewModel.cs" />
+    <Compile Include="Infrastructure\Extensions\ObservableCollectionExtensions.cs" />
+    <Compile Include="Infrastructure\EventTriggerBase.cs" />
+    <Compile Include="Infrastructure\MouseEventTriggers\MouseWheelUpEventTrigger.cs" />
+    <Compile Include="Infrastructure\MouseEventTriggers\MouseWheelDownEventTrigger.cs" />
+    <Compile Include="Infrastructure\ViewModelBase.cs" />
+    <Compile Include="Models\MaterialDefinition\ConcreteDefinition.cs" />
+    <Compile Include="Infrastructure\NamedList.cs" />
+    <Compile Include="Models\MaterialDefinition\MaterialDefinitionBase.cs" />
+    <Compile Include="Models\PrimitiveDefinition\EllipseDefinition.cs" />
+    <Compile Include="Models\PrimitiveDefinition\PrimitiveDefinitionBase.cs" />
+    <Compile Include="Properties\Annotations.cs" />
+    <Compile Include="Models\MaterialDefinition\RebarDefinition.cs" />
+    <Compile Include="Models\PrimitiveDefinition\RectangleDefinition.cs" />
+    <Compile Include="Windows\MainWindow\MainModel.cs" />
+    <Compile Include="Windows\MainWindow\MainView.xaml.cs" />
+    <Compile Include="Windows\MainWindow\MainViewModel.cs" />
+    <Compile Include="Infrastructure\RelayCommand.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Infrastructure\MouseEventTriggers\DoubleClickEventTrigger.cs" />
+    <Compile Include="Infrastructure\EventArgs.cs" />
+    <Compile Include="MaterialCatalogWindow\MaterialCatalogModel.cs" />
+    <Compile Include="MaterialCatalogWindow\MaterialCatalogView.xaml.cs" />
+    <Compile Include="MaterialCatalogWindow\MaterialCatalogViewModel.cs" />
+    <Compile Include="Infrastructure\MouseBehaviour.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="App.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <Page Include="Windows\AddMaterialWindow\AddMaterialView.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
+    <Page Include="Windows\ColorPickerWindow\ColorPickerView.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
+    <Page Include="MaterialCatalogWindow\MaterialCatalogView.xaml">
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+    </Page>
+    <Page Include="Windows\MainWindow\MainView.xaml">
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+    </Page>
+  </ItemGroup>
+  <ItemGroup />
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+</Project>
\ No newline at end of file
diff --git a/StructureHelper.sln b/StructureHelper.sln
new file mode 100644
index 0000000..407de95
--- /dev/null
+++ b/StructureHelper.sln
@@ -0,0 +1,25 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.32002.261
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "StructureHelper", "StructureHelper.csproj", "{BAD27E27-4444-4300-ADF8-E21042C0781D}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{BAD27E27-4444-4300-ADF8-E21042C0781D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{BAD27E27-4444-4300-ADF8-E21042C0781D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{BAD27E27-4444-4300-ADF8-E21042C0781D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{BAD27E27-4444-4300-ADF8-E21042C0781D}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {A4F97ACA-7F64-4D3E-AB47-8EE61B5BAB9A}
+	EndGlobalSection
+EndGlobal
diff --git a/Windows/AddMaterialWindow/AddMaterialView.xaml b/Windows/AddMaterialWindow/AddMaterialView.xaml
new file mode 100644
index 0000000..0817184
--- /dev/null
+++ b/Windows/AddMaterialWindow/AddMaterialView.xaml
@@ -0,0 +1,47 @@
+<Window x:Class="StructureHelper.AddMaterialView"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+        xmlns:local="clr-namespace:StructureHelper"
+        mc:Ignorable="d"
+        d:DataContext="{d:DesignInstance local:AddMaterialViewModel}"
+        Title="Добавление материала" Height="350" Width="400">
+    <Grid>
+        <Grid.RowDefinitions>
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="40"/>
+        </Grid.RowDefinitions>
+        <Grid>
+            <Grid.RowDefinitions>
+                <RowDefinition Height="40"/>
+                <RowDefinition Height="40"/>
+                <RowDefinition Height="{Binding RowHeight}"/>
+                <RowDefinition Height="40"/>
+                <RowDefinition Height="{Binding RowHeight}"/>
+                <RowDefinition Height="40"/>
+                <RowDefinition Height="40"/>
+                <RowDefinition Height="40"/>
+            </Grid.RowDefinitions>
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="2.2*"/>
+                <ColumnDefinition Width="*"/>
+            </Grid.ColumnDefinitions>
+            <TextBlock Grid.Row="0" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Left" Margin="10" Text="Группа материалов"/>
+            <ComboBox Grid.Row="0" Grid.Column="1" Margin="10" ItemsSource="{Binding Materials}" DisplayMemberPath="Name" SelectedItem="{Binding MaterialCollection}"/>
+            <TextBlock Grid.Row="1" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Left" Margin="10" Text="Класс"/>
+            <TextBox Grid.Row="1" Grid.Column="1" Margin="10" Text="{Binding MaterialClass}"/>
+            <TextBlock Grid.Row="2" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Left" Margin="10" Text="Модуль упругости" IsEnabled="{Binding IsNotConcrete}"/>
+            <TextBox Grid.Row="2" Grid.Column="1" Margin="10"  IsEnabled="{Binding IsNotConcrete}" Text="{Binding YoungModulus}"/>
+            <TextBlock Grid.Row="3" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Left" Margin="10" Text="Нормативная прочность на сжатие"/>
+            <TextBox Grid.Row="3" Grid.Column="1" Margin="10" Text="{Binding CompressiveStrengthCoef}"/>
+            <TextBlock Grid.Row="4" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Left" Margin="10" Text="Нормативная прочность на растяжение"  IsEnabled="{Binding IsNotConcrete}"/>
+            <TextBox Grid.Row="4" Grid.Column="1" Margin="10" Text="{Binding TensileStrengthCoef}"  IsEnabled="{Binding IsNotConcrete}"/>
+            <TextBlock Grid.Row="5" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Left" Margin="10" Text="Коэффициент надежности при сжатии"/>
+            <TextBox Grid.Row="5" Grid.Column="1" Margin="10" Text="{Binding MaterialCoefInCompress}"/>
+            <TextBlock Grid.Row="6" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Left" Margin="10" Text="Коэффициент надежности при расширении"/>
+            <TextBox Grid.Row="6" Grid.Column="1" Margin="10" Text="{Binding MaterialCoefInTension}"/>
+        </Grid>
+        <Button Grid.Row="1" Grid.Column="0" Margin="10" HorizontalAlignment="Left" Content="Добавить материал" Command="{Binding AddMaterial}"/>
+    </Grid>
+</Window>
diff --git a/Windows/AddMaterialWindow/AddMaterialView.xaml.cs b/Windows/AddMaterialWindow/AddMaterialView.xaml.cs
new file mode 100644
index 0000000..cf9c865
--- /dev/null
+++ b/Windows/AddMaterialWindow/AddMaterialView.xaml.cs
@@ -0,0 +1,17 @@
+using System.Windows;
+
+namespace StructureHelper
+{
+    /// <summary>
+    /// Логика взаимодействия для AddMaterialView.xaml
+    /// </summary>
+    public partial class AddMaterialView : Window
+    {
+        public AddMaterialView(MaterialCatalogModel model, MaterialCatalogViewModel materialCatalogViewModel)
+        {
+            var viewModel = new AddMaterialViewModel(model, this, materialCatalogViewModel);
+            DataContext = viewModel;
+            InitializeComponent();
+        }
+    }
+}
diff --git a/Windows/AddMaterialWindow/AddMaterialViewModel.cs b/Windows/AddMaterialWindow/AddMaterialViewModel.cs
new file mode 100644
index 0000000..f233678
--- /dev/null
+++ b/Windows/AddMaterialWindow/AddMaterialViewModel.cs
@@ -0,0 +1,82 @@
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Windows.Input;
+using StructureHelper.Infrastructure;
+
+namespace StructureHelper
+{
+    public class AddMaterialViewModel : ViewModelBase
+    {
+        private MaterialCatalogModel model;
+        private AddMaterialView view;
+        private MaterialCatalogViewModel materialCatalogViewModel;
+        public ObservableCollection<NamedList<MaterialDefinitionBase>> Materials { get; set; }
+        private NamedList<MaterialDefinitionBase> materialCollection;
+        public NamedList<MaterialDefinitionBase> MaterialCollection
+        {
+            get => materialCollection;
+            set
+            {
+                OnPropertyChanged(value, materialCollection);
+                OnPropertyChanged(nameof(IsNotConcrete));
+                OnPropertyChanged(nameof(RowHeight));
+            }
+        }
+        public bool IsNotConcrete => MaterialCollection.Name != "Бетон";
+
+        private string materialClass;
+        private double youngModulus, compressiveStrengthCoef, tensileStrengthCoef, materialCoefInCompress, materialCoefInTension;
+
+        public string MaterialClass
+        {
+            get => materialClass;
+            set => OnPropertyChanged(value, ref materialClass);
+        }
+
+        public double YoungModulus
+        {
+            get => youngModulus;
+            set => OnPropertyChanged(value, ref youngModulus);
+        }
+        public double CompressiveStrengthCoef
+        {
+            get => compressiveStrengthCoef;
+            set => OnPropertyChanged(value, ref compressiveStrengthCoef);
+        }
+        public double TensileStrengthCoef
+        {
+            get => tensileStrengthCoef;
+            set => OnPropertyChanged(value, ref tensileStrengthCoef);
+        }
+        public double MaterialCoefInCompress
+        {
+            get => materialCoefInCompress;
+            set => OnPropertyChanged(value, ref materialCoefInCompress);
+        }
+        public double MaterialCoefInTension
+        {
+            get => materialCoefInTension;
+            set => OnPropertyChanged(value, ref materialCoefInTension);
+        }
+        
+        public int RowHeight => IsNotConcrete ? 40 : 0;
+        public ICommand AddMaterial { get; }
+        public AddMaterialViewModel() { }
+        public AddMaterialViewModel(MaterialCatalogModel model, AddMaterialView view, MaterialCatalogViewModel materialCatalogViewModel)
+        {
+            this.model = model;
+            this.view = view;
+            this.materialCatalogViewModel = materialCatalogViewModel;
+            Materials = new ObservableCollection<NamedList<MaterialDefinitionBase>>(model.Materials);
+            MaterialCollection = Materials.First();
+
+            AddMaterial = new RelayCommand(o =>
+            {
+                if (MaterialCollection.Name == "Бетон")
+                    this.materialCatalogViewModel.ConcreteDefinitions.Add(new ConcreteDefinition(MaterialClass, 0, CompressiveStrengthCoef, TensileStrengthCoef, MaterialCoefInCompress, MaterialCoefInTension));
+                if (MaterialCollection.Name == "Арматура")
+                    this.materialCatalogViewModel.RebarDefinitions.Add(new RebarDefinition(MaterialClass, YoungModulus, CompressiveStrengthCoef, TensileStrengthCoef, MaterialCoefInCompress, MaterialCoefInTension));
+            });
+        }
+    }
+}
diff --git a/Windows/ColorPickerWindow/ColorPickerView.xaml b/Windows/ColorPickerWindow/ColorPickerView.xaml
new file mode 100644
index 0000000..0a7a9e9
--- /dev/null
+++ b/Windows/ColorPickerWindow/ColorPickerView.xaml
@@ -0,0 +1,41 @@
+<Window x:Class="StructureHelper.ColorPickerView"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+        xmlns:local="clr-namespace:StructureHelper"
+        mc:Ignorable="d"
+        d:DataContext="{d:DesignInstance local:ColorPickerViewModel}"
+        Title="Выбрать цвет" Height="200" Width="500" Topmost="True" ResizeMode="NoResize">
+    <Grid>
+        <Grid.RowDefinitions>
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="*"/>
+        </Grid.RowDefinitions>
+        <Grid.ColumnDefinitions>
+            <ColumnDefinition Width="80"/>
+            <ColumnDefinition Width="*"/>
+            <ColumnDefinition Width="80"/>
+            <ColumnDefinition Width="80"/>
+        </Grid.ColumnDefinitions>
+        <TextBlock VerticalAlignment="Center" HorizontalAlignment="Left" Margin="10" Text="Красный"/>
+        <Slider Grid.Column="1" VerticalAlignment="Center" HorizontalAlignment="Stretch" Margin="10" Value="{Binding Red}" Minimum="0" Maximum="255"/>
+        <TextBox Grid.Column="2" VerticalAlignment="Center" HorizontalAlignment="Stretch" Margin="10" Text="{Binding Red}"/>
+
+        <Border Grid.Column="3" Grid.RowSpan="3" Margin="10" BorderBrush="Black" BorderThickness="1">
+            <Rectangle Fill="{Binding SelectedColor}"/>
+        </Border>
+
+        <TextBlock Grid.Row="1" VerticalAlignment="Center" HorizontalAlignment="Left" Margin="10" Text="Зеленый"/>
+        <Slider Grid.Row="1" Grid.Column="1" VerticalAlignment="Center" HorizontalAlignment="Stretch" Margin="10" Value="{Binding Green}" Minimum="0" Maximum="255"/>
+        <TextBox Grid.Row="1" Grid.Column="2" VerticalAlignment="Center" HorizontalAlignment="Stretch" Margin="10" Text="{Binding Green}"/>
+
+        <TextBlock Grid.Row="2" VerticalAlignment="Center" HorizontalAlignment="Left" Margin="10" Text="Синий"/>
+        <Slider Grid.Row="2" Grid.Column="1" VerticalAlignment="Center" HorizontalAlignment="Stretch" Margin="10" Value="{Binding Blue}" Minimum="0" Maximum="255"/>
+        <TextBox Grid.Row="2" Grid.Column="2" VerticalAlignment="Center" HorizontalAlignment="Stretch" Margin="10" Text="{Binding Blue}"/>
+
+        <Button Grid.Row="3" Grid.Column="2" Grid.ColumnSpan="2" Margin="10" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Выбрать цвет" Command="{Binding SetColor}"/>
+    </Grid>
+</Window>
diff --git a/Windows/ColorPickerWindow/ColorPickerView.xaml.cs b/Windows/ColorPickerWindow/ColorPickerView.xaml.cs
new file mode 100644
index 0000000..d5838ca
--- /dev/null
+++ b/Windows/ColorPickerWindow/ColorPickerView.xaml.cs
@@ -0,0 +1,17 @@
+using System.Windows;
+
+namespace StructureHelper
+{
+    /// <summary>
+    /// Логика взаимодействия для ColorPickerView.xaml
+    /// </summary>
+    public partial class ColorPickerView : Window
+    {
+        public ColorPickerView(PrimitiveDefinition primitive)
+        {
+            var viewModel = new ColorPickerViewModel(primitive);
+            DataContext = viewModel;
+            InitializeComponent();
+        }
+    }
+}
diff --git a/Windows/ColorPickerWindow/ColorPickerViewModel.cs b/Windows/ColorPickerWindow/ColorPickerViewModel.cs
new file mode 100644
index 0000000..3d056a3
--- /dev/null
+++ b/Windows/ColorPickerWindow/ColorPickerViewModel.cs
@@ -0,0 +1,64 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Windows.Input;
+using System.Windows.Media;
+using StructureHelper.Infrastructure;
+
+namespace StructureHelper
+{
+    public class ColorPickerViewModel : ViewModelBase
+    {
+        private int red, green, blue;
+
+        public int Red
+        {
+            get => red;
+            set => OnColorItemChanged(value, ref red);
+        }
+        public int Green
+        {
+            get => green;
+            set => OnColorItemChanged(value, ref green);
+        }
+        public int Blue
+        {
+            get => blue;
+            set => OnColorItemChanged(value, ref blue);
+        }
+
+        private SolidColorBrush selectedColor;
+        public SolidColorBrush SelectedColor
+        {
+            get => selectedColor;
+            set => OnPropertyChanged(value, selectedColor);
+        }
+        public ICommand SetColor { get; }
+        public ColorPickerViewModel(PrimitiveDefinitionBase primitive)
+        {
+            if (primitive != null)
+            {
+                var solidBrush = primitive.Brush;
+                Red = solidBrush.Color.R;
+                Green = solidBrush.Color.G;
+                Blue = solidBrush.Color.B;
+
+                SetColor = new RelayCommand(o => primitive.Brush = SelectedColor);
+            }
+        }
+        private void OnColorItemChanged(int value, ref int colorItem, [CallerMemberName] string propertyName = null)
+        {
+            if (value >= 0 && value <= 255 && Math.Abs(colorItem - value) > 0.001)
+            {
+                colorItem = value;
+                OnPropertyChanged(propertyName);
+                UpdateSelectedColor();
+            }
+        }
+        private void UpdateSelectedColor()
+        {
+            var color = Color.FromRgb((byte)Red, (byte)Green, (byte)Blue);
+            SelectedColor = new SolidColorBrush(color);
+            OnPropertyChanged(nameof(SelectedColor));
+        }
+    }
+}
diff --git a/Windows/MainWindow/MainModel.cs b/Windows/MainWindow/MainModel.cs
new file mode 100644
index 0000000..70dfd26
--- /dev/null
+++ b/Windows/MainWindow/MainModel.cs
@@ -0,0 +1,7 @@
+namespace StructureHelper
+{
+    public class MainModel
+    {
+
+    }
+}
diff --git a/Windows/MainWindow/MainView.xaml b/Windows/MainWindow/MainView.xaml
new file mode 100644
index 0000000..43b03ad
--- /dev/null
+++ b/Windows/MainWindow/MainView.xaml
@@ -0,0 +1,318 @@
+<Window x:Class="StructureHelper.MainView"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+        xmlns:local="clr-namespace:StructureHelper"
+        xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"
+        xmlns:infrastructure="clr-namespace:StructureHelper.Infrastructure"
+        mc:Ignorable="d"
+        d:DataContext="{d:DesignInstance local:MainViewModel}"
+        Title="StructureHelper" Height="700" Width="1000">
+    <Window.InputBindings>
+        <KeyBinding Command="{Binding SetParameters}" Key="Enter"/>
+    </Window.InputBindings>
+    <Window.Resources>
+        <DataTemplate x:Key="rectangleTemplate">
+            <DockPanel>
+                <Border x:Name="Border" Width="{Binding BorderWidth, Mode=TwoWay}" Height="{Binding BorderHeight, Mode=TwoWay}" Background="{Binding Brush, Mode=TwoWay}" 
+                        Opacity="{Binding Opacity, Mode=TwoWay}">
+                    <i:Interaction.Triggers>
+                        <i:EventTrigger EventName="PreviewMouseDown">
+                            <i:InvokeCommandAction Command="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.PrimitiveLeftButtonDown}" CommandParameter="{Binding}"/>
+                        </i:EventTrigger>
+                        <i:EventTrigger EventName="PreviewMouseUp">
+                            <i:InvokeCommandAction Command="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.PrimitiveLeftButtonUp}" CommandParameter="{Binding}"/>
+                        </i:EventTrigger>
+                        <i:EventTrigger EventName="PreviewMouseMove">
+                            <i:InvokeCommandAction Command="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.BorderPreviewMouseMove}" CommandParameter="{Binding}"/>
+                        </i:EventTrigger>
+                        <infrastructure:DoubleClickEventTrigger EventName="MouseDown">
+                            <i:InvokeCommandAction Command="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.PrimitiveDoubleClick}" CommandParameter="{Binding}"/>
+                        </infrastructure:DoubleClickEventTrigger>
+                    </i:Interaction.Triggers>
+                    <Border.ToolTip>
+                        <ToolTip Background="White" BorderBrush="Black" BorderThickness="1">
+                            <Grid>
+                                <Grid.RowDefinitions>
+                                    <RowDefinition Height="30"/>
+                                    <RowDefinition Height="30"/>
+                                    <RowDefinition Height="30"/>
+                                    <RowDefinition Height="30"/>
+                                    <RowDefinition Height="30"/>
+                                </Grid.RowDefinitions>
+                                <Grid.ColumnDefinitions>
+                                    <ColumnDefinition Width="100"/>
+                                    <ColumnDefinition Width="50"/>
+                                </Grid.ColumnDefinitions>
+                                <TextBox Grid.Row="0" Grid.Column="0" VerticalAlignment="Center" Margin="3" BorderThickness="0" Text="Координата X:"/>
+                                <TextBox Grid.Row="0" Grid.Column="1" VerticalAlignment="Center" Margin="3" BorderThickness="0" Text="{Binding ShowedRectX}"/>
+                                <TextBox Grid.Row="1" Grid.Column="0" VerticalAlignment="Center" Margin="3" BorderThickness="0" Text="Координата Y:"/>
+                                <TextBox Grid.Row="1" Grid.Column="1" VerticalAlignment="Center" Margin="3" BorderThickness="0" Text="{Binding ShowedRectY}"/>
+                                <TextBox Grid.Row="2" Grid.Column="0" VerticalAlignment="Center" Margin="3" BorderThickness="0" Text="Ширина:"/>
+                                <TextBox Grid.Row="2" Grid.Column="1" VerticalAlignment="Center" Margin="3" BorderThickness="0" Text="{Binding BorderWidth}"/>
+                                <TextBox Grid.Row="3" Grid.Column="0" VerticalAlignment="Center" Margin="3" BorderThickness="0" Text="Высота:"/>
+                                <TextBox Grid.Row="3" Grid.Column="1" VerticalAlignment="Center" Margin="3" BorderThickness="0" Text="{Binding BorderHeight}"/>
+                                <TextBox Grid.Row="4" Grid.Column="0" VerticalAlignment="Center" Margin="3" BorderThickness="0" Text="Материал:"/>
+                                <TextBox Grid.Row="4" Grid.Column="1" VerticalAlignment="Center" Margin="3" BorderThickness="0" Text="{Binding MaterialName, Mode=TwoWay}"/>
+                            </Grid>
+                        </ToolTip>
+                    </Border.ToolTip>
+                    <Rectangle Name="testRect" Fill="{Binding Brush, Mode=TwoWay}" Width="20" Height="20" StrokeThickness="2" Stroke="{Binding Brush, Mode=TwoWay}" HorizontalAlignment="Right" VerticalAlignment="Bottom" Cursor="SizeNWSE">
+                        <i:Interaction.Triggers>
+                            <i:EventTrigger EventName="PreviewMouseDown">
+                                <i:InvokeCommandAction Command="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.LeftButtonDown}" CommandParameter="{Binding}"/>
+                            </i:EventTrigger>
+                            <i:EventTrigger EventName="PreviewMouseUp">
+                                <i:InvokeCommandAction Command="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.LeftButtonUp}" CommandParameter="{Binding}"/>
+                            </i:EventTrigger>
+                            <i:EventTrigger EventName="PreviewMouseMove">
+                                <i:InvokeCommandAction Command="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.PreviewMouseMove}" CommandParameter="{Binding}"/>
+                            </i:EventTrigger>
+                        </i:Interaction.Triggers>
+                    </Rectangle>
+                </Border>
+                <Popup IsOpen="{Binding ParamsPanelVisibilty}">
+                    <i:Interaction.Triggers>
+                        <i:EventTrigger EventName="MouseLeave">
+                            <i:InvokeCommandAction Command="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.SetPopupCanBeClosedTrue}" CommandParameter="{Binding}"/>
+                        </i:EventTrigger>
+                        <i:EventTrigger EventName="MouseEnter">
+                            <i:InvokeCommandAction Command="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.SetPopupCanBeClosedFalse}" CommandParameter="{Binding}"/>
+                        </i:EventTrigger>
+                    </i:Interaction.Triggers>
+                    <Border Background="White" BorderBrush="Black" BorderThickness="1">
+                        <Grid Grid.Column="1">
+                            <Grid.RowDefinitions>
+                                <RowDefinition Height="40"/>
+                                <RowDefinition Height="40"/>
+                                <RowDefinition Height="40"/>
+                                <RowDefinition Height="40"/>
+                                <RowDefinition Height="40"/>
+                                <RowDefinition Height="40"/>
+                                <RowDefinition Height="40"/>
+                                <RowDefinition Height="40"/>
+                                <RowDefinition Height="40"/>
+                                <RowDefinition Height="40"/>
+                                <RowDefinition Height="40"/>
+                                <RowDefinition Height="*"/>
+                            </Grid.RowDefinitions>
+                            <Grid.ColumnDefinitions>
+                                <ColumnDefinition Width="170"/>
+                                <ColumnDefinition Width="170"/>
+                            </Grid.ColumnDefinitions>
+                            <TextBlock VerticalAlignment="Center" HorizontalAlignment="Left" Text="Координата X" Margin="10"/>
+                            <TextBox Grid.Column="1" VerticalAlignment="Center" Margin="10" Text="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.RectParameterX, Mode=TwoWay}"/>
+                            <TextBlock Grid.Row="1" VerticalAlignment="Center" HorizontalAlignment="Left" Text="Координата Y" Margin="10"/>
+                            <TextBox Grid.Column="1" Grid.Row="1" VerticalAlignment="Center" Margin="10" Text="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.RectParameterY, Mode=TwoWay}"/>
+                            <TextBlock Grid.Row="2" VerticalAlignment="Center" HorizontalAlignment="Left" Text="Ширина" Margin="10"/>
+                            <TextBox Grid.Column="1" Grid.Row="2" VerticalAlignment="Center" Margin="10" Text="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.RectParameterWidth, Mode=TwoWay}"/>
+                            <TextBlock Grid.Row="3" VerticalAlignment="Center" HorizontalAlignment="Left" Text="Высота" Margin="10"/>
+                            <TextBox Grid.Row="3" Grid.Column="1" VerticalAlignment="Center" Margin="10" Text="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.RectParameterHeight, Mode=TwoWay}"/>
+                            <TextBlock Grid.Row="4" VerticalAlignment="Center" HorizontalAlignment="Left" Text="Материал" Margin="10"/>
+                            <Button Grid.Row="4" Grid.Column="1" Margin="10" Background="White" 
+                                    Command="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.OpenMaterialCatalogWithSelection}" CommandParameter="{Binding}"
+                                    Content="{Binding MaterialName, Mode=TwoWay}"/>
+                            <TextBlock Grid.Row="5" VerticalAlignment="Center" HorizontalAlignment="Left" Margin="10" Text="Цвет"/>
+                            <Button Grid.Row="5" Grid.Column="1" Margin="10" Background="{Binding Brush, Mode=TwoWay}"
+                                    Command="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.SetColor}" CommandParameter="{Binding}"/>
+                            <TextBlock Grid.Row="6" Margin="10" VerticalAlignment="Center" HorizontalAlignment="Left" Text="Прозрачность"/>
+                            <TextBox Grid.Row="6" Grid.Column="1" VerticalAlignment="Center" Margin="10,10,50,10" Text="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.ParameterOpacity, Mode=TwoWay}"/>
+                            <TextBlock Grid.Row="6" Grid.Column="1" VerticalAlignment="Center" HorizontalAlignment="Right" Text="%" Margin="25,10"/>
+                            <TextBlock Grid.Row="7" VerticalAlignment="Center" HorizontalAlignment="Left" Margin="10" Text="Заблокировать объект" Grid.ColumnSpan="2"/>
+                            <CheckBox Grid.Row="7" Grid.Column="1" VerticalAlignment="Center" HorizontalAlignment="Left" Margin="10" IsChecked="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.ElementLock, Mode=TwoWay}"></CheckBox>
+                            <TextBlock Grid.Row="8" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Left" Margin="10" Text="Z-порядок"/>
+                            <StackPanel Grid.Row="8" Grid.Column="1" Orientation="Horizontal">
+                                <TextBox VerticalAlignment="Center" HorizontalAlignment="Left" Width="50" Margin="10"
+                                         Text="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.PrimitiveIndex, Mode=TwoWay}"/>
+                                <TextBlock VerticalAlignment="Center" Text="Max = "/>
+                                <TextBlock VerticalAlignment="Center" Text="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.PrimitivesCount, Mode=TwoWay}"/>
+                            </StackPanel>
+                            <Button Grid.Row="9" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Center" Content="Установить впереди всех" Margin="10"
+                                    Command="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.SetInFrontOfAll}" CommandParameter="{Binding}"/>
+                            <Button Grid.Row="9" Grid.Column="1" VerticalAlignment="Center" HorizontalAlignment="Center" Content="Установить позади всех" Margin="10"
+                                    Command="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.SetInBackOfAll}" CommandParameter="{Binding}"/>
+                            <Button Grid.Row="10" Grid.Column="0" Grid.ColumnSpan="2" VerticalAlignment="Center" HorizontalAlignment="Right" Margin="10" Content="Установить параметры" 
+                                    Command="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.SetParameters}" CommandParameter="{Binding}"/>
+                        </Grid>
+                    </Border>
+                </Popup>
+            </DockPanel>
+        </DataTemplate>
+        <DataTemplate x:Key="ellipseTemplate">
+            <DockPanel>
+                <Ellipse Width="{Binding Diameter}" Height="{Binding Diameter}" Fill="{Binding Brush, Mode=TwoWay}" Opacity="{Binding Opacity, Mode=TwoWay}">
+                    <i:Interaction.Triggers>
+                        <i:EventTrigger EventName="PreviewMouseDown">
+                            <i:InvokeCommandAction Command="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.PrimitiveLeftButtonDown}" CommandParameter="{Binding}"/>
+                        </i:EventTrigger>
+                        <i:EventTrigger EventName="PreviewMouseUp">
+                            <i:InvokeCommandAction Command="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.PrimitiveLeftButtonUp}" CommandParameter="{Binding}"/>
+                        </i:EventTrigger>
+                        <i:EventTrigger EventName="PreviewMouseMove">
+                            <i:InvokeCommandAction Command="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.EllipsePreviewMouseMove}" CommandParameter="{Binding}"/>
+                        </i:EventTrigger>
+                        <infrastructure:DoubleClickEventTrigger EventName="MouseDown">
+                            <i:InvokeCommandAction Command="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.PrimitiveDoubleClick}" CommandParameter="{Binding}"/>
+                        </infrastructure:DoubleClickEventTrigger>
+                    </i:Interaction.Triggers>
+                    <Ellipse.ToolTip>
+                        <ToolTip Background="White" BorderBrush="Black" BorderThickness="1">
+                            <Grid>
+                                <Grid.RowDefinitions>
+                                    <RowDefinition Height="30"/>
+                                    <RowDefinition Height="30"/>
+                                    <RowDefinition Height="30"/>
+                                    <RowDefinition Height="30"/>
+                                </Grid.RowDefinitions>
+                                <Grid.ColumnDefinitions>
+                                    <ColumnDefinition Width="150"/>
+                                    <ColumnDefinition Width="50"/>
+                                </Grid.ColumnDefinitions>
+                                <TextBox Grid.Row="0" Grid.Column="0" VerticalAlignment="Center" Margin="3" BorderThickness="0" Text="Координата центра X:"/>
+                                <TextBox Grid.Row="0" Grid.Column="1" VerticalAlignment="Center" Margin="3" BorderThickness="0" Text="{Binding ShowedEllipseX}"/>
+                                <TextBox Grid.Row="1" Grid.Column="0" VerticalAlignment="Center" Margin="3" BorderThickness="0" Text="Координата центра Y:"/>
+                                <TextBox Grid.Row="1" Grid.Column="1" VerticalAlignment="Center" Margin="3" BorderThickness="0" Text="{Binding ShowedEllipseY}"/>
+                                <TextBox Grid.Row="2" Grid.Column="0" VerticalAlignment="Center" Margin="3" BorderThickness="0" Text="Диаметр:"/>
+                                <TextBox Grid.Row="2" Grid.Column="1" VerticalAlignment="Center" Margin="3" BorderThickness="0" Text="{Binding ShowedDiameter}"/>
+                                <TextBox Grid.Row="4" Grid.Column="0" VerticalAlignment="Center" Margin="3" BorderThickness="0" Text="Материал:"/>
+                                <TextBox Grid.Row="4" Grid.Column="1" VerticalAlignment="Center" Margin="3" BorderThickness="0" Text="{Binding MaterialName, Mode=TwoWay}"/>
+                            </Grid>
+                        </ToolTip>
+                    </Ellipse.ToolTip>
+                </Ellipse>
+                <Popup IsOpen="{Binding ParamsPanelVisibilty}">
+                    <i:Interaction.Triggers>
+                        <i:EventTrigger EventName="MouseLeave">
+                            <i:InvokeCommandAction Command="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.SetPopupCanBeClosedTrue}" CommandParameter="{Binding}"/>
+                        </i:EventTrigger>
+                        <i:EventTrigger EventName="MouseEnter">
+                            <i:InvokeCommandAction Command="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.SetPopupCanBeClosedFalse}" CommandParameter="{Binding}"/>
+                        </i:EventTrigger>
+                    </i:Interaction.Triggers>
+                    <Border Background="White" BorderBrush="Black" BorderThickness="1">
+                        <Grid Grid.Column="1">
+                            <Grid.RowDefinitions>
+                                <RowDefinition Height="40"/>
+                                <RowDefinition Height="40"/>
+                                <RowDefinition Height="40"/>
+                                <RowDefinition Height="40"/>
+                                <RowDefinition Height="40"/>
+                                <RowDefinition Height="40"/>
+                                <RowDefinition Height="40"/>
+                                <RowDefinition Height="40"/>
+                                <RowDefinition Height="40"/>
+                                <RowDefinition Height="40"/>
+                                <RowDefinition Height="40"/>
+                                <RowDefinition Height="*"/>
+                            </Grid.RowDefinitions>
+                            <Grid.ColumnDefinitions>
+                                <ColumnDefinition Width="170"/>
+                                <ColumnDefinition Width="170"/>
+                            </Grid.ColumnDefinitions>
+                            <TextBlock VerticalAlignment="Center" HorizontalAlignment="Left" Text="Координата центра X" Margin="10"/>
+                            <TextBox Grid.Column="1" VerticalAlignment="Center" Margin="10" Text="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.EllipseParameterX, Mode=TwoWay}"/>
+                            <TextBlock Grid.Row="1" VerticalAlignment="Center" HorizontalAlignment="Left" Text="Координата центра Y" Margin="10"/>
+                            <TextBox Grid.Column="1" Grid.Row="1" VerticalAlignment="Center" Margin="10" Text="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.EllipseParameterY, Mode=TwoWay}"/>
+                            <TextBlock Grid.Row="2" VerticalAlignment="Center" HorizontalAlignment="Left" Text="Площадь" Margin="10"/>
+                            <TextBox Grid.Column="1" Grid.Row="2" VerticalAlignment="Center" Margin="10" Text="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.EllipseParameterSquare, Mode=TwoWay}"/>
+                            <TextBlock Grid.Row="4" VerticalAlignment="Center" HorizontalAlignment="Left" Text="Материал" Margin="10"/>
+                            <Button Grid.Row="4" Grid.Column="1" Margin="10" Background="White" 
+                                    Command="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.OpenMaterialCatalogWithSelection}" CommandParameter="{Binding}"
+                                    Content="{Binding MaterialName, Mode=TwoWay}"/>
+                            <TextBlock Grid.Row="5" VerticalAlignment="Center" HorizontalAlignment="Left" Margin="10" Text="Цвет"/>
+                            <Button Grid.Row="5" Grid.Column="1" Margin="10" Background="{Binding Brush, Mode=TwoWay}"
+                                    Command="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.SetColor}" CommandParameter="{Binding}"/>
+                            <TextBlock Grid.Row="6" Margin="10" VerticalAlignment="Center" HorizontalAlignment="Left" Text="Прозрачность"/>
+                            <TextBox Grid.Row="6" Grid.Column="1" VerticalAlignment="Center" Margin="10,10,50,10" Text="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.ParameterOpacity, Mode=TwoWay}"/>
+                            <TextBlock Grid.Row="6" Grid.Column="1" VerticalAlignment="Center" HorizontalAlignment="Right" Text="%" Margin="25,10"/>
+                            <TextBlock Grid.Row="7" VerticalAlignment="Center" HorizontalAlignment="Left" Margin="10" Text="Заблокировать объект" Grid.ColumnSpan="2"/>
+                            <CheckBox Grid.Row="7" Grid.Column="1" VerticalAlignment="Center" HorizontalAlignment="Left" Margin="10" IsChecked="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.ElementLock, Mode=TwoWay}"></CheckBox>
+                            <TextBlock Grid.Row="8" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Left" Margin="10" Text="Z-порядок"/>
+                            <StackPanel Grid.Row="8" Grid.Column="1" Orientation="Horizontal">
+                                <TextBox VerticalAlignment="Center" HorizontalAlignment="Left" Width="50" Margin="10"
+                                         Text="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.PrimitiveIndex, Mode=TwoWay}"/>
+                                <TextBlock VerticalAlignment="Center" Text="Max = "/>
+                                <TextBlock VerticalAlignment="Center" Text="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.PrimitivesCount, Mode=TwoWay}"/>
+                            </StackPanel>
+                            <Button Grid.Row="9" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Center" Content="Установить впереди всех" Margin="10"
+                                    Command="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.SetInFrontOfAll}" CommandParameter="{Binding}"/>
+                            <Button Grid.Row="9" Grid.Column="1" VerticalAlignment="Center" HorizontalAlignment="Center" Content="Установить позади всех" Margin="10"
+                                    Command="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.SetInBackOfAll}" CommandParameter="{Binding}"/>
+                            <Button Grid.Row="10" Grid.Column="0" Grid.ColumnSpan="2" VerticalAlignment="Center" HorizontalAlignment="Right" Margin="10" Content="Установить параметры" 
+                                    Command="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.SetParameters}" CommandParameter="{Binding}"/>
+                        </Grid>
+                    </Border>
+                </Popup>
+            </DockPanel>
+        </DataTemplate>
+    </Window.Resources>
+    <Grid>
+        <Grid.RowDefinitions>
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="40"/>
+            <RowDefinition Height="40"/>
+        </Grid.RowDefinitions>
+        <Border BorderBrush="Black" Background="White" BorderThickness="1" Margin="5">
+            <i:Interaction.Triggers>
+                <i:EventTrigger EventName="PreviewMouseDown">
+                    <i:InvokeCommandAction Command="{Binding ClearSelection}" CommandParameter="{Binding}"/>
+                </i:EventTrigger>
+            </i:Interaction.Triggers>
+            <ScrollViewer VerticalScrollBarVisibility="Visible" HorizontalScrollBarVisibility="Visible">
+                <Canvas ClipToBounds="True" Width="{Binding CanvasWidth}" Height="{Binding CanvasHeight}">
+                    <i:Interaction.Behaviors>
+                        <local:MouseBehaviour MouseX="{Binding PanelX, Mode=OneWayToSource}" MouseY="{Binding PanelY, Mode=OneWayToSource}"/>
+                    </i:Interaction.Behaviors>
+                    <i:Interaction.Triggers>
+                        <infrastructure:MouseWheelDownEventTrigger EventName="PreviewMouseWheel">
+                            <i:InvokeCommandAction Command="{Binding ScaleCanvasDown}" CommandParameter="{Binding}"/>
+                        </infrastructure:MouseWheelDownEventTrigger>
+                        <infrastructure:MouseWheelUpEventTrigger EventName="PreviewMouseWheel">
+                            <i:InvokeCommandAction Command="{Binding ScaleCanvasUp}" CommandParameter="{Binding}"/>
+                        </infrastructure:MouseWheelUpEventTrigger>
+                    </i:Interaction.Triggers>
+                    <Canvas.RenderTransform>
+                        <TransformGroup>
+                            <ScaleTransform ScaleX="{Binding ScaleValue}" ScaleY="{Binding ScaleValue}"
+                                            CenterX="{Binding ScrollPanelX}" CenterY="{Binding ScrollPanelY}"/>
+                        </TransformGroup>
+                    </Canvas.RenderTransform>
+                    <Canvas.Background>
+                        <DrawingBrush Viewport="0,0,10,10" ViewportUnits="Absolute" TileMode="Tile">
+                            <DrawingBrush.Drawing>
+                                <GeometryDrawing Brush="Black">
+                                    <GeometryDrawing.Geometry>
+                                        <GeometryGroup FillRule="EvenOdd">
+                                            <RectangleGeometry Rect="0,0,50,50"/>
+                                            <RectangleGeometry Rect="0,0,49.5,49.5"/>
+                                        </GeometryGroup>
+                                    </GeometryDrawing.Geometry>
+                                </GeometryDrawing>
+                            </DrawingBrush.Drawing>
+                        </DrawingBrush>
+                    </Canvas.Background>
+                    <Line X1="0" X2="{Binding XX2}" Y1="{Binding XY1}" Y2="{Binding XY1}" Stroke="Red" StrokeThickness="1"/>
+                    <Line X1="{Binding YX1}" X2="{Binding YX1}" Y1="0" Y2="{Binding YY2}" Stroke="ForestGreen" StrokeThickness="1"/>
+                    <ItemsControl ItemsSource="{Binding Primitives}" ItemTemplate="{Binding}">
+                        <ItemsControl.ItemsPanel>
+                            <ItemsPanelTemplate>
+                                <Canvas/>
+                            </ItemsPanelTemplate>
+                        </ItemsControl.ItemsPanel>
+                        <ItemsControl.ItemContainerStyle>
+                            <Style TargetType="ContentPresenter">
+                                <Setter Property="Canvas.ZIndex" Value="{Binding ZIndex}"/>
+                                <Setter Property="Canvas.Left" Value="{Binding X}"/>
+                                <Setter Property="Canvas.Top" Value="{Binding Y}"/>
+                            </Style>
+                        </ItemsControl.ItemContainerStyle>
+                    </ItemsControl>
+                </Canvas>
+            </ScrollViewer>
+        </Border>
+        <Button Grid.Row="1" VerticalAlignment="Center" HorizontalAlignment="Left" Margin="10" Content="Справочник" Command="{Binding OpenMaterialCatalog}"/>
+        <Button Grid.Row="1" VerticalAlignment="Center" HorizontalAlignment="Right" Margin="10" Content="Добавить прямоугольник" Command="{Binding AddRectangle}"/>
+        <Button Grid.Row="2" VerticalAlignment="Center" HorizontalAlignment="Right" Margin="10" Content="Добавить точку" Command="{Binding AddEllipse}"/>
+    </Grid>
+</Window>
diff --git a/Windows/MainWindow/MainView.xaml.cs b/Windows/MainWindow/MainView.xaml.cs
new file mode 100644
index 0000000..aa74418
--- /dev/null
+++ b/Windows/MainWindow/MainView.xaml.cs
@@ -0,0 +1,15 @@
+using System.Windows;
+
+namespace StructureHelper
+{
+    public partial class MainView : Window
+    {
+        public MainView()
+        {
+            var model = new MainModel();
+            var viewModel = new MainViewModel(model, this);
+            DataContext = viewModel;
+            InitializeComponent();
+        }
+    }
+}
diff --git a/Windows/MainWindow/MainViewModel.cs b/Windows/MainWindow/MainViewModel.cs
new file mode 100644
index 0000000..fb9120b
--- /dev/null
+++ b/Windows/MainWindow/MainViewModel.cs
@@ -0,0 +1,408 @@
+using System;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Windows.Input;
+using StructureHelper.Infrastructure;
+
+namespace StructureHelper
+{
+    public class MainViewModel : ViewModelBase
+    {
+        private MainModel rectanglesModel;
+        private MainView rectanglesView;
+        public ObservableCollection<RectangleDefinition> Rectangles { get; set; }
+        public ObservableCollection<EllipseDefinition> Ellipses { get; set; }
+        public ObservableCollection<PrimitiveDefinition> Primitives { get; set; }
+        public ICommand AddRectangle { get; }
+
+        private double panelX, panelY, scrollPanelX, scrollPanelY;
+
+        public double PanelX
+        {
+            get => panelX;
+            set => OnPropertyChanged(value, ref panelX);
+        }
+        public double PanelY
+        {
+            get => panelY;
+            set => OnPropertyChanged(value, ref panelY);
+        }
+        public double ScrollPanelX
+        {
+            get => scrollPanelX;
+            set => OnPropertyChanged(value, ref scrollPanelX);
+        }
+        public double ScrollPanelY
+        {
+            get => scrollPanelY;
+            set => OnPropertyChanged(value, ref scrollPanelY);
+        }
+
+        private double rectParameterX, rectParameterY, rectParameterWidth, rectParameterHeight;
+
+        public double RectParameterX
+        {
+            get => rectParameterX;
+            set => OnPropertyChanged(value, ref rectParameterX);
+        }
+        public double RectParameterY
+        {
+            get => rectParameterY;
+            set => OnPropertyChanged(value, ref rectParameterY);
+        }
+        public double RectParameterWidth
+        {
+            get => rectParameterWidth;
+            set => OnPropertyChanged(value, ref rectParameterWidth);
+        }
+        public double RectParameterHeight
+        {
+            get => rectParameterHeight;
+            set => OnPropertyChanged(value, ref rectParameterHeight);
+        }
+
+        private double parameterOpacity = 0;
+
+        public double ParameterOpacity
+        {
+            get => parameterOpacity;
+            set
+            {
+                if (value >= 0 && value <= 100) 
+                    OnPropertyChanged(value, ref parameterOpacity);
+            }
+        }
+
+        private double ellipseParameterX, ellipseParameterY, ellipseParameterSquare;
+        public double EllipseParameterX
+        {
+            get => ellipseParameterX;
+            set => OnPropertyChanged(value, ref ellipseParameterX);
+        }
+
+        public double EllipseParameterY
+        {
+            get => ellipseParameterY;
+            set => OnPropertyChanged(value, ref ellipseParameterY);
+        }
+
+        public double EllipseParameterSquare
+        {
+            get => ellipseParameterSquare;
+            set => OnPropertyChanged(value, ref ellipseParameterSquare);
+        }
+        private bool elementLock;
+        public bool ElementLock
+        {
+            get => elementLock;
+            set => OnPropertyChanged(value, ref elementLock);
+        }
+
+        private int primitivesCount;
+        public int PrimitivesCount
+        {
+            get => primitivesCount;
+            set => OnPropertyChanged(value, ref primitivesCount);
+        }
+
+        private int primitiveIndex = 1;
+        public int PrimitiveIndex
+        {
+            get => primitiveIndex;
+            set
+            {
+                if (value >= 0 && value <= primitivesCount)
+                    OnPropertyChanged(value, ref primitiveIndex);
+            }
+        }
+
+        private double scaleValue = 1.0;
+        public double ScaleValue
+        {
+            get => scaleValue;
+            set => OnPropertyChanged(value, ref scaleValue);
+        }
+
+        private double canvasWidth, canvasHeight, xX2, xY1, yX1, yY2;
+        public double CanvasWidth
+        {
+            get => canvasWidth;
+            set => OnPropertyChanged(value, ref canvasWidth);
+        }
+
+        public double CanvasHeight
+        {
+            get => canvasHeight;
+            set => OnPropertyChanged(value, ref canvasHeight);
+        }
+
+        public double XX2
+        {
+            get => xX2;
+            set => OnPropertyChanged(value, ref xX2);
+        }
+        public double XY1
+        {
+            get => xY1;
+            set => OnPropertyChanged(value, ref xY1);
+        }
+        public double YX1
+        {
+            get => yX1;
+            set => OnPropertyChanged(value, ref yX1);
+        }
+        public double YY2
+        {
+            get => yY2;
+            set => OnPropertyChanged(value, ref yY2);
+        }
+
+        private double delta = 0.5;
+
+        public ICommand LeftButtonDown { get; }
+        public ICommand LeftButtonUp { get; }
+        public ICommand PreviewMouseMove { get; }
+        public ICommand PrimitiveLeftButtonDown { get; }
+        public ICommand PrimitiveLeftButtonUp { get; }
+        public ICommand BorderPreviewMouseMove { get; }
+        public ICommand PrimitiveDoubleClick { get; }
+        public ICommand SetParameters { get; }
+        public ICommand ClearSelection { get; }
+        public ICommand SetPopupCanBeClosedTrue { get; }
+        public ICommand SetPopupCanBeClosedFalse { get; }
+        public ICommand OpenMaterialCatalog { get; }
+        public ICommand OpenMaterialCatalogWithSelection { get; }
+        public ICommand SetColor { get; }
+        public ICommand SetInFrontOfAll { get; }
+        public ICommand SetInBackOfAll { get; }
+        public ICommand ScaleCanvasDown { get; }
+        public ICommand ScaleCanvasUp { get; }
+        public ICommand AddEllipse { get; }
+        public ICommand EllipsePreviewMouseMove { get; }
+
+        public MainViewModel() { }
+        public MainViewModel(MainModel rectanglesModel, MainView rectanglesView)
+        {
+            this.rectanglesModel = rectanglesModel;
+            this.rectanglesView = rectanglesView;
+
+            CanvasWidth = 1500;
+            CanvasHeight = 1000;
+            XX2 = CanvasWidth;
+            XY1 = CanvasHeight / 2;
+            YX1 = CanvasWidth / 2;
+            YY2 = CanvasHeight;
+
+            BorderPreviewMouseMove = new RelayCommand(o =>
+            {
+                var rect = o as RectangleDefinition;
+                if (rect.Captured && !rect.BorderCaptured && !rect.ElementLock)
+                {
+                    var deltaX = rect.BorderWidth / 2;
+                    var deltaY = rect.BorderHeight / 2;
+
+                    if (rect.ShowedRectX % 10 <= delta || rect.ShowedRectX % 10 >= 10 - delta)
+                        rect.ShowedRectX = Math.Round((PanelX - deltaX - YX1) / 10) * 10;
+                    else
+                        rect.ShowedRectX = PanelX - deltaX - YX1;
+
+                    if (rect.ShowedRectY % 10 <= delta || rect.ShowedRectY % 10 >= 10 - delta)
+                        rect.ShowedRectY = -(Math.Round((PanelY - deltaY - XY1 + rect.BorderHeight) / 10) * 10);
+                    else
+                        rect.ShowedRectY = -(PanelY - deltaY - XY1 + rect.BorderHeight);
+                }
+                if (rect.ParameterCaptured)
+                {
+                    RectParameterX = rect.ShowedRectX;
+                    RectParameterY = rect.ShowedRectY;
+                    RectParameterWidth = rect.BorderWidth;
+                    RectParameterHeight = rect.BorderHeight;
+                    ParameterOpacity = rect.ShowedOpacity;
+                    ElementLock = rect.ElementLock;
+                }
+            });
+            PrimitiveLeftButtonUp = new RelayCommand(o =>
+            {
+                var primitive = o as PrimitiveDefinition;
+                primitive.Captured = false;
+            });
+            PrimitiveLeftButtonDown = new RelayCommand(o =>
+            {
+                var primitive = o as PrimitiveDefinition;
+                primitive.Captured = true;
+                foreach (var primitiveDefinition in Primitives)
+                    primitiveDefinition.ParameterCaptured = false;
+                primitive.ParameterCaptured = true;
+            });
+            LeftButtonUp = new RelayCommand(o =>
+            {
+                var rect = o as RectangleDefinition;
+                rect.BorderCaptured = false;
+            });
+            LeftButtonDown = new RelayCommand(o =>
+            {
+                var rect = o as RectangleDefinition;
+                rect.BorderCaptured = true;
+            });
+            PreviewMouseMove = new RelayCommand(o =>
+            {
+                var rect = o as RectangleDefinition;
+                if (rect.BorderCaptured && rect.Captured && !rect.ElementLock)
+                {
+                    if (rect.BorderWidth % 10 < delta || rect.BorderWidth % 10 >= delta)
+                        rect.BorderWidth = Math.Round(PanelX / 10) * 10 - rect.RectX + 10;
+                    else
+                        rect.BorderWidth = PanelX - rect.RectX + 10;
+
+                    if (rect.BorderHeight % 10 < delta || rect.BorderHeight % 10 >= delta)
+                        rect.BorderHeight = Math.Round(PanelY / 10) * 10 - rect.RectY + 10;
+                    else
+                        rect.BorderHeight = PanelY - rect.RectY + 10;
+                }
+            });
+            SetParameters = new RelayCommand(o =>
+            {
+                var primitive = Primitives.FirstOrDefault(x => x.ParameterCaptured);
+                primitive.ElementLock = ElementLock;
+                primitive.ShowedOpacity = ParameterOpacity;
+                Primitives.MoveElementToSelectedIndex(primitive, PrimitiveIndex);
+                foreach (var primitiveDefinition in Primitives)
+                    primitiveDefinition.ShowedZIndex = Primitives.IndexOf(primitiveDefinition) + 1;
+
+                if (primitive is RectangleDefinition rectangle)
+                {
+                    rectangle.ShowedRectX = RectParameterX;
+                    rectangle.ShowedRectY = RectParameterY;
+                    rectangle.BorderWidth = RectParameterWidth;
+                    rectangle.BorderHeight = RectParameterHeight;
+                }
+
+                if (primitive is EllipseDefinition ellipse)
+                {
+                    ellipse.Square = EllipseParameterSquare;
+                    ellipse.ShowedEllipseX = EllipseParameterX;
+                    ellipse.ShowedEllipseY = EllipseParameterY;
+                }
+            });
+            ClearSelection = new RelayCommand(o =>
+            {
+                var primitive = Primitives.FirstOrDefault(x => x.ParamsPanelVisibilty);
+                if (primitive != null && primitive.PopupCanBeClosed)
+                    primitive.ParamsPanelVisibilty = false;
+            });
+            PrimitiveDoubleClick = new RelayCommand(o =>
+            {
+                var primitive = o as PrimitiveDefinition;
+                primitive.PopupCanBeClosed = false;
+                primitive.Captured = false;
+                primitive.ParamsPanelVisibilty = true;
+
+                if (primitive is RectangleDefinition rect)
+                    rect.BorderCaptured = false;
+            });
+            SetPopupCanBeClosedTrue = new RelayCommand(o =>
+            {
+                var primitiveParamsVisible = Primitives.FirstOrDefault(x => x.ParameterCaptured);
+                primitiveParamsVisible.PopupCanBeClosed = true;
+            });
+            SetPopupCanBeClosedFalse = new RelayCommand(o =>
+            {
+                var primitiveParamsVisible = Primitives.FirstOrDefault(x => x.ParameterCaptured);
+                primitiveParamsVisible.PopupCanBeClosed = false;
+            });
+            OpenMaterialCatalog = new RelayCommand(o =>
+            {
+                var materialCatalogView = new MaterialCatalogView();
+                materialCatalogView.ShowDialog();
+            });
+            OpenMaterialCatalogWithSelection = new RelayCommand(o =>
+            {
+                var primitive = o as PrimitiveDefinition;
+                var materialCatalogView = new MaterialCatalogView(true, primitive);
+                materialCatalogView.ShowDialog();
+            });
+            SetColor = new RelayCommand(o =>
+            {
+                var primitive = o as PrimitiveDefinition;
+                var colorPickerView = new ColorPickerView(primitive);
+                colorPickerView.ShowDialog();
+            });
+            SetInFrontOfAll = new RelayCommand(o =>
+            {
+                var primitive = o as PrimitiveDefinition;
+                foreach (var primitiveDefinition in Primitives)
+                    if (primitiveDefinition.ShowedZIndex > primitive.ShowedZIndex && primitiveDefinition != primitive)
+                        primitiveDefinition.ShowedZIndex--;
+                primitive.ShowedZIndex = PrimitivesCount;
+                OnPropertyChanged(nameof(primitive.ShowedZIndex));
+            });
+            SetInBackOfAll = new RelayCommand(o =>
+            {
+                var primitive = o as PrimitiveDefinition;
+                foreach (var primitiveDefinition in Primitives)
+                    if (primitiveDefinition.ShowedZIndex < primitive.ShowedZIndex && primitiveDefinition != primitive)
+                        primitiveDefinition.ShowedZIndex++;
+                primitive.ShowedZIndex = 1;
+                OnPropertyChanged(nameof(primitive.ShowedZIndex));
+            });
+            ScaleCanvasDown = new RelayCommand(o =>
+            {
+                var scaleRate = 1.1;
+                ScrollPanelX = PanelX;
+                ScrollPanelY = PanelY;
+                ScaleValue *= scaleRate;
+            });
+            ScaleCanvasUp = new RelayCommand(o =>
+            {
+                var scaleRate = 1.1;
+                ScrollPanelX = PanelX;
+                ScrollPanelY = PanelY;
+                ScaleValue /= scaleRate;
+            });
+
+            Primitives = new ObservableCollection<PrimitiveDefinition>();
+            Rectangles = new ObservableCollection<RectangleDefinition>();
+            Ellipses = new ObservableCollection<EllipseDefinition>();
+            AddRectangle = new RelayCommand(o =>
+            {
+                var rectangle = new RectangleDefinition(60, 40, YX1, XY1);
+                Rectangles.Add(rectangle);
+                Primitives.Add(rectangle);
+                PrimitivesCount = Primitives.Count;
+            });
+            AddEllipse = new RelayCommand(o =>
+            {
+                var ellipse = new EllipseDefinition(2000, YX1, XY1);
+                Ellipses.Add(ellipse);
+                Primitives.Add(ellipse);
+                PrimitivesCount = Primitives.Count;
+            });
+            EllipsePreviewMouseMove = new RelayCommand(o =>
+            {
+                if (!(o is EllipseDefinition ellipse)) return;
+                if (ellipse.Captured && !ellipse.ElementLock)
+                {
+                    var delta = ellipse.Diameter / 2;
+
+                    if (ellipse.ShowedEllipseX % 10 <= delta || ellipse.ShowedEllipseX % 10 >= 10 - delta)
+                        ellipse.ShowedEllipseX = Math.Round((PanelX - YX1) / 10) * 10;
+                    else
+                        ellipse.ShowedEllipseX = PanelX - delta - YX1;
+
+                    if (ellipse.ShowedEllipseY % 10 <= delta || ellipse.ShowedEllipseY % 10 >= 10 - delta)
+                        ellipse.ShowedEllipseY = -(Math.Round((PanelY - XY1) / 10) * 10);
+                    else
+                        ellipse.ShowedEllipseY = -(PanelY - delta - XY1);
+                }
+                if (ellipse.ParameterCaptured)
+                {
+                    EllipseParameterX = ellipse.ShowedEllipseX;
+                    EllipseParameterY = ellipse.ShowedEllipseY;
+                    EllipseParameterSquare = ellipse.Square;
+                    ParameterOpacity = ellipse.ShowedOpacity;
+                    ElementLock = ellipse.ElementLock;
+                }
+            });
+        }
+    }
+}
diff --git a/packages.config b/packages.config
new file mode 100644
index 0000000..e7d7544
--- /dev/null
+++ b/packages.config
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Newtonsoft.Json" version="12.0.1" targetFramework="net472" />
+  <package id="System.Windows.Interactivity.WPF" version="2.0.20525" targetFramework="net472" />
+</packages>
\ No newline at end of file