Moved Object Model to separate project

2015-06-24 19:57:16 +01:00 · 2015-06-24 19:57:16 +01:00 · c6f5dcda39
parent 1be6fe9e7b
commit c6f5dcda39
75 changed files with 1271 additions and 294 deletions
--- a/Filtration.ObjectModel.Tests/TestItemFilterBlock.cs
+++ b/Filtration.ObjectModel.Tests/TestItemFilterBlock.cs
@ -1,8 +1,7 @@
-using Filtration.Models;
-using Filtration.Models.BlockItemTypes;
+using Filtration.ObjectModel.BlockItemTypes;
 using NUnit.Framework;

-namespace Filtration.Tests.Models
+namespace Filtration.ObjectModel.Tests
 {
    [TestFixture]
    public class TestItemFilterBlock
--- a/Filtration.ObjectModel.Tests/TestItemFilterScript.cs
+++ b/Filtration.ObjectModel.Tests/TestItemFilterScript.cs
@ -1,11 +1,9 @@
-using System.Collections.ObjectModel;
-using System.Linq;
+using System.Linq;
 using System.Windows.Media;
-using Filtration.Models;
-using Filtration.Models.BlockItemTypes;
+using Filtration.ObjectModel.BlockItemTypes;
 using NUnit.Framework;

-namespace Filtration.Tests.Models
+namespace Filtration.ObjectModel.Tests
 {
    [TestFixture]
    public class TestItemFilterScript
--- a/Filtration.ObjectModel/BlockItemBaseTypes/ActionBlockItem.cs
+++ b/Filtration.ObjectModel/BlockItemBaseTypes/ActionBlockItem.cs
@ -1,10 +1,10 @@
 using System.Windows.Media;
-using Filtration.Enums;
-using Filtration.Extensions;
+using Filtration.ObjectModel.Enums;
+using Filtration.ObjectModel.Extensions;

-namespace Filtration.Models.BlockItemBaseTypes
+namespace Filtration.ObjectModel.BlockItemBaseTypes
 {
-    internal class ActionBlockItem : BlockItemBase
+    public class ActionBlockItem : BlockItemBase
    {
        private BlockAction _action;

--- a/Filtration.ObjectModel/BlockItemBaseTypes/BlockItembase.cs
+++ b/Filtration.ObjectModel/BlockItemBaseTypes/BlockItembase.cs
@ -1,11 +1,11 @@
 using System.ComponentModel;
 using System.Runtime.CompilerServices;
 using System.Windows.Media;
-using Filtration.Annotations;
+using Filtration.ObjectModel.Annotations;

-namespace Filtration.Models.BlockItemBaseTypes
+namespace Filtration.ObjectModel.BlockItemBaseTypes
 {
-    abstract class BlockItemBase : IItemFilterBlockItem
+    public abstract class BlockItemBase : IItemFilterBlockItem
    {
        public abstract string PrefixText { get; }
        public abstract string OutputText { get; }
@ -17,6 +17,7 @@ namespace Filtration.Models.BlockItemBaseTypes
        public abstract int SortOrder { get; }

        public event PropertyChangedEventHandler PropertyChanged;
+        
        [NotifyPropertyChangedInvocator]
        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
        {
--- a/Filtration.ObjectModel/BlockItemBaseTypes/ColorBlockItem.cs
+++ b/Filtration.ObjectModel/BlockItemBaseTypes/ColorBlockItem.cs
@ -1,8 +1,8 @@
 using System.Windows.Media;

-namespace Filtration.Models.BlockItemBaseTypes
+namespace Filtration.ObjectModel.BlockItemBaseTypes
 {
-    internal abstract class ColorBlockItem : BlockItemBase, IAudioVisualBlockItem
+    public abstract class ColorBlockItem : BlockItemBase, IAudioVisualBlockItem
    {
        private Color _color;

--- a/Filtration.ObjectModel/BlockItemBaseTypes/DualIntegerBlockItem.cs
+++ b/Filtration.ObjectModel/BlockItemBaseTypes/DualIntegerBlockItem.cs
@ -1,8 +1,8 @@
 using System.Windows.Media;

-namespace Filtration.Models.BlockItemBaseTypes
+namespace Filtration.ObjectModel.BlockItemBaseTypes
 {
-    internal abstract class DualIntegerBlockItem : BlockItemBase, IAudioVisualBlockItem
+    public abstract class DualIntegerBlockItem : BlockItemBase, IAudioVisualBlockItem
    {
        private int _value;
        private int _secondValue;
--- a/Filtration.ObjectModel/BlockItemBaseTypes/IntegerBlockItem.cs
+++ b/Filtration.ObjectModel/BlockItemBaseTypes/IntegerBlockItem.cs
@ -1,8 +1,8 @@
 using System.Windows.Media;

-namespace Filtration.Models.BlockItemBaseTypes
+namespace Filtration.ObjectModel.BlockItemBaseTypes
 {
-    internal abstract class IntegerBlockItem : BlockItemBase, IAudioVisualBlockItem
+    public abstract class IntegerBlockItem : BlockItemBase, IAudioVisualBlockItem
    {
        private int _value;

--- a/Filtration.ObjectModel/BlockItemBaseTypes/NumericFilterPredicateBlockItem.cs
+++ b/Filtration.ObjectModel/BlockItemBaseTypes/NumericFilterPredicateBlockItem.cs
@ -1,10 +1,10 @@
 using System;
-using Filtration.Enums;
-using Filtration.Extensions;
+using Filtration.ObjectModel.Enums;
+using Filtration.ObjectModel.Extensions;

-namespace Filtration.Models.BlockItemBaseTypes
+namespace Filtration.ObjectModel.BlockItemBaseTypes
 {
-    internal abstract class NumericFilterPredicateBlockItem : BlockItemBase
+    public abstract class NumericFilterPredicateBlockItem : BlockItemBase
    {
        private NumericFilterPredicate _filterPredicate;

--- a/Filtration.ObjectModel/BlockItemBaseTypes/StringListBlockItem.cs
+++ b/Filtration.ObjectModel/BlockItemBaseTypes/StringListBlockItem.cs
@ -3,9 +3,9 @@ using System.Collections.ObjectModel;
 using System.Collections.Specialized;
 using System.Linq;

-namespace Filtration.Models.BlockItemBaseTypes
+namespace Filtration.ObjectModel.BlockItemBaseTypes
 {
-    internal abstract class StringListBlockItem : BlockItemBase
+    public abstract class StringListBlockItem : BlockItemBase
    {
        protected StringListBlockItem()
        {
--- a/Filtration.ObjectModel/BlockItemTypes/BackgroundColorBlockItem.cs
+++ b/Filtration.ObjectModel/BlockItemTypes/BackgroundColorBlockItem.cs
@ -1,9 +1,9 @@
 using System.Windows.Media;
-using Filtration.Models.BlockItemBaseTypes;
+using Filtration.ObjectModel.BlockItemBaseTypes;

-namespace Filtration.Models.BlockItemTypes
+namespace Filtration.ObjectModel.BlockItemTypes
 {
-    internal class BackgroundColorBlockItem : ColorBlockItem
+    public class BackgroundColorBlockItem : ColorBlockItem
    {
        public BackgroundColorBlockItem()
        {
--- a/Filtration.ObjectModel/BlockItemTypes/BaseTypeBlockItem.cs
+++ b/Filtration.ObjectModel/BlockItemTypes/BaseTypeBlockItem.cs
@ -1,10 +1,10 @@
 using System.Linq;
 using System.Windows.Media;
-using Filtration.Models.BlockItemBaseTypes;
+using Filtration.ObjectModel.BlockItemBaseTypes;

-namespace Filtration.Models.BlockItemTypes
+namespace Filtration.ObjectModel.BlockItemTypes
 {
-    internal class BaseTypeBlockItem : StringListBlockItem
+    public class BaseTypeBlockItem : StringListBlockItem
    {
        public override string PrefixText { get { return "BaseType"; } }

--- a/Filtration.ObjectModel/BlockItemTypes/BorderColorBlockItem.cs
+++ b/Filtration.ObjectModel/BlockItemTypes/BorderColorBlockItem.cs
@ -1,9 +1,9 @@
 using System.Windows.Media;
-using Filtration.Models.BlockItemBaseTypes;
+using Filtration.ObjectModel.BlockItemBaseTypes;

-namespace Filtration.Models.BlockItemTypes
+namespace Filtration.ObjectModel.BlockItemTypes
 {
-    internal class BorderColorBlockItem : ColorBlockItem
+    public class BorderColorBlockItem : ColorBlockItem
    {
        public BorderColorBlockItem()
        {
--- a/Filtration.ObjectModel/BlockItemTypes/ClassBlockItem.cs
+++ b/Filtration.ObjectModel/BlockItemTypes/ClassBlockItem.cs
@ -1,10 +1,10 @@
 using System.Linq;
 using System.Windows.Media;
-using Filtration.Models.BlockItemBaseTypes;
+using Filtration.ObjectModel.BlockItemBaseTypes;

-namespace Filtration.Models.BlockItemTypes
+namespace Filtration.ObjectModel.BlockItemTypes
 {
-    internal class ClassBlockItem : StringListBlockItem
+    public class ClassBlockItem : StringListBlockItem
    {
        public override string PrefixText { get { return "Class"; } }

--- a/Filtration.ObjectModel/BlockItemTypes/DropLevelBlockItem.cs
+++ b/Filtration.ObjectModel/BlockItemTypes/DropLevelBlockItem.cs
@ -1,10 +1,10 @@
 using System.Windows.Media;
-using Filtration.Enums;
-using Filtration.Models.BlockItemBaseTypes;
+using Filtration.ObjectModel.BlockItemBaseTypes;
+using Filtration.ObjectModel.Enums;

-namespace Filtration.Models.BlockItemTypes
+namespace Filtration.ObjectModel.BlockItemTypes
 {
-    internal class DropLevelBlockItem : NumericFilterPredicateBlockItem
+    public class DropLevelBlockItem : NumericFilterPredicateBlockItem
    {
        public DropLevelBlockItem()
        {
--- a/Filtration.ObjectModel/BlockItemTypes/FontSizeBlockItem.cs
+++ b/Filtration.ObjectModel/BlockItemTypes/FontSizeBlockItem.cs
@ -1,8 +1,8 @@
-using Filtration.Models.BlockItemBaseTypes;
+using Filtration.ObjectModel.BlockItemBaseTypes;

-namespace Filtration.Models.BlockItemTypes
+namespace Filtration.ObjectModel.BlockItemTypes
 {
-    internal class FontSizeBlockItem : IntegerBlockItem
+    public class FontSizeBlockItem : IntegerBlockItem
    {
        public FontSizeBlockItem()
        {
--- a/Filtration.ObjectModel/BlockItemTypes/HeightBlockItem.cs
+++ b/Filtration.ObjectModel/BlockItemTypes/HeightBlockItem.cs
@ -1,10 +1,10 @@
 using System.Windows.Media;
-using Filtration.Enums;
-using Filtration.Models.BlockItemBaseTypes;
+using Filtration.ObjectModel.BlockItemBaseTypes;
+using Filtration.ObjectModel.Enums;

-namespace Filtration.Models.BlockItemTypes
+namespace Filtration.ObjectModel.BlockItemTypes
 {
-    internal class HeightBlockItem : NumericFilterPredicateBlockItem
+    public class HeightBlockItem : NumericFilterPredicateBlockItem
    {
        public HeightBlockItem()
        {
--- a/Filtration.ObjectModel/BlockItemTypes/ItemLevelBlockItem.cs
+++ b/Filtration.ObjectModel/BlockItemTypes/ItemLevelBlockItem.cs
@ -1,10 +1,10 @@
 using System.Windows.Media;
-using Filtration.Enums;
-using Filtration.Models.BlockItemBaseTypes;
+using Filtration.ObjectModel.BlockItemBaseTypes;
+using Filtration.ObjectModel.Enums;

-namespace Filtration.Models.BlockItemTypes
+namespace Filtration.ObjectModel.BlockItemTypes
 {
-    internal class ItemLevelBlockItem : NumericFilterPredicateBlockItem
+    public class ItemLevelBlockItem : NumericFilterPredicateBlockItem
    {
        public ItemLevelBlockItem()
        {
--- a/Filtration.ObjectModel/BlockItemTypes/LinkedSocketsBlockItem.cs
+++ b/Filtration.ObjectModel/BlockItemTypes/LinkedSocketsBlockItem.cs
@ -1,10 +1,10 @@
 using System.Windows.Media;
-using Filtration.Enums;
-using Filtration.Models.BlockItemBaseTypes;
+using Filtration.ObjectModel.BlockItemBaseTypes;
+using Filtration.ObjectModel.Enums;

-namespace Filtration.Models.BlockItemTypes
+namespace Filtration.ObjectModel.BlockItemTypes
 {
-    internal class LinkedSocketsBlockItem : NumericFilterPredicateBlockItem
+    public class LinkedSocketsBlockItem : NumericFilterPredicateBlockItem
    {
        public LinkedSocketsBlockItem()
        {
--- a/Filtration.ObjectModel/BlockItemTypes/QualityBlockItem.cs
+++ b/Filtration.ObjectModel/BlockItemTypes/QualityBlockItem.cs
@ -1,10 +1,10 @@
 using System.Windows.Media;
-using Filtration.Enums;
-using Filtration.Models.BlockItemBaseTypes;
+using Filtration.ObjectModel.BlockItemBaseTypes;
+using Filtration.ObjectModel.Enums;

-namespace Filtration.Models.BlockItemTypes
+namespace Filtration.ObjectModel.BlockItemTypes
 {
-    internal class QualityBlockItem : NumericFilterPredicateBlockItem
+    public class QualityBlockItem : NumericFilterPredicateBlockItem
    {
        public QualityBlockItem()
        {
--- a/Filtration.ObjectModel/BlockItemTypes/RarityBlockItem.cs
+++ b/Filtration.ObjectModel/BlockItemTypes/RarityBlockItem.cs
@ -1,11 +1,11 @@
 using System.Windows.Media;
-using Filtration.Enums;
-using Filtration.Extensions;
-using Filtration.Models.BlockItemBaseTypes;
+using Filtration.ObjectModel.BlockItemBaseTypes;
+using Filtration.ObjectModel.Enums;
+using Filtration.ObjectModel.Extensions;

-namespace Filtration.Models.BlockItemTypes
+namespace Filtration.ObjectModel.BlockItemTypes
 {
-    internal class RarityBlockItem : NumericFilterPredicateBlockItem
+    public class RarityBlockItem : NumericFilterPredicateBlockItem
    {
        public RarityBlockItem()
        {
--- a/Filtration.ObjectModel/BlockItemTypes/SocketGroupBlockItem.cs
+++ b/Filtration.ObjectModel/BlockItemTypes/SocketGroupBlockItem.cs
@ -1,10 +1,10 @@
 using System.Linq;
 using System.Windows.Media;
-using Filtration.Models.BlockItemBaseTypes;
+using Filtration.ObjectModel.BlockItemBaseTypes;

-namespace Filtration.Models.BlockItemTypes
+namespace Filtration.ObjectModel.BlockItemTypes
 {
-    internal class SocketGroupBlockItem : StringListBlockItem
+    public class SocketGroupBlockItem : StringListBlockItem
    {
        public override string PrefixText
        {
--- a/Filtration.ObjectModel/BlockItemTypes/SocketsBlockItem.cs
+++ b/Filtration.ObjectModel/BlockItemTypes/SocketsBlockItem.cs
@ -1,10 +1,10 @@
 using System.Windows.Media;
-using Filtration.Enums;
-using Filtration.Models.BlockItemBaseTypes;
+using Filtration.ObjectModel.BlockItemBaseTypes;
+using Filtration.ObjectModel.Enums;

-namespace Filtration.Models.BlockItemTypes
+namespace Filtration.ObjectModel.BlockItemTypes
 {
-    internal class SocketsBlockItem : NumericFilterPredicateBlockItem
+    public class SocketsBlockItem : NumericFilterPredicateBlockItem
    {
        public SocketsBlockItem()
        {
--- a/Filtration.ObjectModel/BlockItemTypes/SoundBlockItem.cs
+++ b/Filtration.ObjectModel/BlockItemTypes/SoundBlockItem.cs
@ -1,8 +1,8 @@
-using Filtration.Models.BlockItemBaseTypes;
+using Filtration.ObjectModel.BlockItemBaseTypes;

-namespace Filtration.Models.BlockItemTypes
+namespace Filtration.ObjectModel.BlockItemTypes
 {
-    internal class SoundBlockItem : DualIntegerBlockItem
+    public class SoundBlockItem : DualIntegerBlockItem
    {
        public SoundBlockItem()
        {
--- a/Filtration.ObjectModel/BlockItemTypes/TextColorBlockItem.cs
+++ b/Filtration.ObjectModel/BlockItemTypes/TextColorBlockItem.cs
@ -1,9 +1,9 @@
 using System.Windows.Media;
-using Filtration.Models.BlockItemBaseTypes;
+using Filtration.ObjectModel.BlockItemBaseTypes;

-namespace Filtration.Models.BlockItemTypes
+namespace Filtration.ObjectModel.BlockItemTypes
 {
-    internal class TextColorBlockItem : ColorBlockItem
+    public class TextColorBlockItem : ColorBlockItem
    {
        public TextColorBlockItem()
        {
--- a/Filtration.ObjectModel/BlockItemTypes/WidthBlockItem.cs
+++ b/Filtration.ObjectModel/BlockItemTypes/WidthBlockItem.cs
@ -1,10 +1,10 @@
 using System.Windows.Media;
-using Filtration.Enums;
-using Filtration.Models.BlockItemBaseTypes;
+using Filtration.ObjectModel.BlockItemBaseTypes;
+using Filtration.ObjectModel.Enums;

-namespace Filtration.Models.BlockItemTypes
+namespace Filtration.ObjectModel.BlockItemTypes
 {
-    internal class WidthBlockItem : NumericFilterPredicateBlockItem
+    public class WidthBlockItem : NumericFilterPredicateBlockItem
    {
        public WidthBlockItem()
        {
--- a/Filtration.ObjectModel/Enums/BlockAction.cs
+++ b/Filtration.ObjectModel/Enums/BlockAction.cs
@ -1,8 +1,8 @@
 using System.ComponentModel;

-namespace Filtration.Enums
+namespace Filtration.ObjectModel.Enums
 {
-    internal enum BlockAction
+    public enum BlockAction
    {
        [Description("Show")]
        Show,
--- a/Filtration.ObjectModel/Enums/BlockItemType.cs
+++ b/Filtration.ObjectModel/Enums/BlockItemType.cs
@ -1,6 +1,6 @@
-namespace Filtration.Enums
+namespace Filtration.ObjectModel.Enums
 {
-    internal enum BlockItemType
+    public enum BlockItemType
    {
        ItemLevel,
        DropLevel,
--- a/Filtration.ObjectModel/Enums/FilterPredicateOperator.cs
+++ b/Filtration.ObjectModel/Enums/FilterPredicateOperator.cs
@ -1,8 +1,8 @@
 using System.ComponentModel;

-namespace Filtration.Enums
+namespace Filtration.ObjectModel.Enums
 {
-    internal enum FilterPredicateOperator
+    public enum FilterPredicateOperator
    {
        [Description("=")]
        Equal,
--- a/Filtration.ObjectModel/Enums/FilterType.cs
+++ b/Filtration.ObjectModel/Enums/FilterType.cs
@ -1,8 +1,8 @@
 using System.ComponentModel;

-namespace Filtration.Enums
+namespace Filtration.ObjectModel.Enums
 {
-    internal enum FilterType
+    public enum FilterType
    {
        [Description("Show")]
        Show,
--- a/Filtration.ObjectModel/Enums/ItemRarity.cs
+++ b/Filtration.ObjectModel/Enums/ItemRarity.cs
@ -1,8 +1,8 @@
 using System.ComponentModel;

-namespace Filtration.Enums
+namespace Filtration.ObjectModel.Enums
 {
-    internal enum ItemRarity
+    public enum ItemRarity
    {
        [Description("Normal")]
        Normal,
--- a/Filtration.ObjectModel/Enums/SocketColor.cs
+++ b/Filtration.ObjectModel/Enums/SocketColor.cs
@ -1,8 +1,8 @@
 using System.ComponentModel;

-namespace Filtration.Enums
+namespace Filtration.ObjectModel.Enums
 {
-    internal enum SocketColor
+    public enum SocketColor
    {
        [Description("R")]
        Red,
--- a/Filtration.ObjectModel/Extensions/EnumHelper.cs
+++ b/Filtration.ObjectModel/Extensions/EnumHelper.cs
@ -1,9 +1,9 @@
 using System;
 using System.ComponentModel;

-namespace Filtration.Extensions
+namespace Filtration.ObjectModel.Extensions
 {
-    internal static class EnumHelper
+    public static class EnumHelper
    {
        public static T GetAttributeOfType<T>(this Enum enumVal) where T : Attribute
        {
--- a/Filtration.ObjectModel/Filtration.ObjectModel.csproj
+++ b/Filtration.ObjectModel/Filtration.ObjectModel.csproj
@ -0,0 +1,92 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" DefaultTargets="Build" 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>{4AAC3BEB-1DC1-483E-9D11-0E9334E80227}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Filtration.ObjectModel</RootNamespace>
+    <AssemblyName>Filtration.ObjectModel</AssemblyName>
+    <TargetFrameworkVersion>v4.5.1</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <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' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="PresentationCore" />
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="BlockItemBaseTypes\ActionBlockItem.cs" />
+    <Compile Include="BlockItemBaseTypes\BlockItembase.cs" />
+    <Compile Include="BlockItemBaseTypes\ColorBlockItem.cs" />
+    <Compile Include="BlockItemBaseTypes\DualIntegerBlockItem.cs" />
+    <Compile Include="BlockItemBaseTypes\IntegerBlockItem.cs" />
+    <Compile Include="BlockItemBaseTypes\NumericFilterPredicateBlockItem.cs" />
+    <Compile Include="BlockItemBaseTypes\StringListBlockItem.cs" />
+    <Compile Include="BlockItemTypes\BackgroundColorBlockItem.cs" />
+    <Compile Include="BlockItemTypes\BaseTypeBlockItem.cs" />
+    <Compile Include="BlockItemTypes\BorderColorBlockItem.cs" />
+    <Compile Include="BlockItemTypes\ClassBlockItem.cs" />
+    <Compile Include="BlockItemTypes\DropLevelBlockItem.cs" />
+    <Compile Include="BlockItemTypes\FontSizeBlockItem.cs" />
+    <Compile Include="BlockItemTypes\HeightBlockItem.cs" />
+    <Compile Include="BlockItemTypes\ItemLevelBlockItem.cs" />
+    <Compile Include="BlockItemTypes\LinkedSocketsBlockItem.cs" />
+    <Compile Include="BlockItemTypes\QualityBlockItem.cs" />
+    <Compile Include="BlockItemTypes\RarityBlockItem.cs" />
+    <Compile Include="BlockItemTypes\SocketGroupBlockItem.cs" />
+    <Compile Include="BlockItemTypes\SocketsBlockItem.cs" />
+    <Compile Include="BlockItemTypes\SoundBlockItem.cs" />
+    <Compile Include="BlockItemTypes\TextColorBlockItem.cs" />
+    <Compile Include="BlockItemTypes\WidthBlockItem.cs" />
+    <Compile Include="Enums\BlockAction.cs" />
+    <Compile Include="Enums\BlockItemType.cs" />
+    <Compile Include="Enums\FilterPredicateOperator.cs" />
+    <Compile Include="Enums\FilterType.cs" />
+    <Compile Include="Enums\ItemRarity.cs" />
+    <Compile Include="Enums\SocketColor.cs" />
+    <Compile Include="Extensions\EnumHelper.cs" />
+    <Compile Include="IAudioVisualBlockItem.cs" />
+    <Compile Include="IItemFilterBlockItem.cs" />
+    <Compile Include="ItemFilterBlock.cs" />
+    <Compile Include="ItemFilterBlockGroup.cs" />
+    <Compile Include="ItemFilterScript.cs" />
+    <Compile Include="ItemFilterSection.cs" />
+    <Compile Include="NumericFilterPredicate.cs" />
+    <Compile Include="Properties\Annotations.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="ReplaceColorsParameterSet.cs" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
--- a/Filtration.ObjectModel/IAudioVisualBlockItem.cs
+++ b/Filtration.ObjectModel/IAudioVisualBlockItem.cs
@ -1,8 +1,8 @@
 using System.ComponentModel;

-namespace Filtration.Models
+namespace Filtration.ObjectModel
 {
-    internal interface IAudioVisualBlockItem
+    public interface IAudioVisualBlockItem
    {
        event PropertyChangedEventHandler PropertyChanged;
    }
--- a/Filtration.ObjectModel/IItemFilterBlockItem.cs
+++ b/Filtration.ObjectModel/IItemFilterBlockItem.cs
@ -1,9 +1,9 @@
 using System.ComponentModel;
 using System.Windows.Media;

-namespace Filtration.Models
+namespace Filtration.ObjectModel
 {
-    internal interface IItemFilterBlockItem : INotifyPropertyChanged
+    public interface IItemFilterBlockItem : INotifyPropertyChanged
    {
        string PrefixText { get; }
        string OutputText { get; }
--- a/Filtration.ObjectModel/ItemFilterBlock.cs
+++ b/Filtration.ObjectModel/ItemFilterBlock.cs
@ -1,12 +1,12 @@
 using System;
 using System.Collections.ObjectModel;
 using System.Linq;
-using Filtration.Enums;
-using Filtration.Models.BlockItemBaseTypes;
+using Filtration.ObjectModel.BlockItemBaseTypes;
+using Filtration.ObjectModel.Enums;

-namespace Filtration.Models
+namespace Filtration.ObjectModel
 {
-    internal class ItemFilterBlock
+    public class ItemFilterBlock
    {
        private ItemFilterBlockGroup _blockGroup;

@ -100,7 +100,7 @@ namespace Filtration.Models
            {
                Action = BlockAction.Hide;
            }
-            else if (BlockGroup.IsChecked == true && Action == BlockAction.Hide)
+            else if (BlockGroup.IsChecked && Action == BlockAction.Hide)
            {
                Action = BlockAction.Show;
            }
--- a/Filtration.ObjectModel/ItemFilterBlockGroup.cs
+++ b/Filtration.ObjectModel/ItemFilterBlockGroup.cs
@ -1,9 +1,9 @@
 using System;
 using System.Collections.Generic;

-namespace Filtration.Models
+namespace Filtration.ObjectModel
 {
-    internal class ItemFilterBlockGroup
+    public class ItemFilterBlockGroup
    {
        private bool _isChecked;

--- a/Filtration.ObjectModel/ItemFilterScript.cs
+++ b/Filtration.ObjectModel/ItemFilterScript.cs
@ -2,11 +2,11 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
-using Filtration.Models.BlockItemTypes;
+using Filtration.ObjectModel.BlockItemTypes;

-namespace Filtration.Models
+namespace Filtration.ObjectModel
 {
-    internal class ItemFilterScript
+    public class ItemFilterScript
    {
        public ItemFilterScript()
        {
--- a/Filtration.ObjectModel/ItemFilterSection.cs
+++ b/Filtration.ObjectModel/ItemFilterSection.cs
@ -0,0 +1,6 @@
+namespace Filtration.ObjectModel
+{
+    public class ItemFilterSection : ItemFilterBlock
+    {
+    }
+}
--- a/Filtration.ObjectModel/NumericFilterPredicate.cs
+++ b/Filtration.ObjectModel/NumericFilterPredicate.cs
@ -1,12 +1,12 @@
 using System.ComponentModel;
 using System.Runtime.CompilerServices;
-using Filtration.Annotations;
-using Filtration.Enums;
-using Filtration.Extensions;
+using Filtration.ObjectModel.Annotations;
+using Filtration.ObjectModel.Enums;
+using Filtration.ObjectModel.Extensions;

-namespace Filtration.Models
+namespace Filtration.ObjectModel
 {
-    internal class NumericFilterPredicate : INotifyPropertyChanged
+    public class NumericFilterPredicate : INotifyPropertyChanged
    {
        private FilterPredicateOperator _predicateOperator;
        private int _predicateOperand;
--- a/Filtration.ObjectModel/Properties/Annotations.cs
+++ b/Filtration.ObjectModel/Properties/Annotations.cs
@ -0,0 +1,937 @@
+using System;
+
+#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
+// ReSharper disable CheckNamespace
+
+namespace Filtration.ObjectModel.Annotations
+{
+  /// <summary>
+  /// Indicates that the value of the marked element could be <c>null</c> sometimes,
+  /// so the check for <c>null</c> is necessary before its usage.
+  /// </summary>
+  /// <example><code>
+  /// [CanBeNull] public object Test() { return null; }
+  /// public 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)]
+  public sealed class CanBeNullAttribute : Attribute { }
+
+  /// <summary>
+  /// Indicates that the value of the marked element could never be <c>null</c>.
+  /// </summary>
+  /// <example><code>
+  /// [NotNull] public object Foo() {
+  ///   return null; // Warning: Possible 'null' assignment
+  /// }
+  /// </code></example>
+  [AttributeUsage(
+    AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
+    AttributeTargets.Delegate | AttributeTargets.Field | AttributeTargets.Event)]
+  public sealed class NotNullAttribute : Attribute { }
+
+  /// <summary>
+  /// Indicates that collection or enumerable value does not contain null elements.
+  /// </summary>
+  [AttributeUsage(
+    AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
+    AttributeTargets.Delegate | AttributeTargets.Field)]
+  public sealed class ItemNotNullAttribute : Attribute { }
+
+  /// <summary>
+  /// Indicates that collection or enumerable value can contain null elements.
+  /// </summary>
+  [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 format pattern and (optional) arguments.
+  /// Parameter, which contains format string, should be given in constructor. The format string
+  /// should be in <see cref="string.Format(IFormatProvider,string,object[])"/>-like form.
+  /// </summary>
+  /// <example><code>
+  /// [StringFormatMethod("message")]
+  /// public void ShowError(string message, params object[] args) { /* do something */ }
+  /// public 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 format-string
+    /// </param>
+    public StringFormatMethodAttribute(string formatParameterName)
+    {
+      FormatParameterName = formatParameterName;
+    }
+
+    public string FormatParameterName { get; private set; }
+  }
+
+  /// <summary>
+  /// For a parameter that is expected to be one of the limited set of values.
+  /// Specify fields of which type should be used as values for this parameter.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.Field)]
+  public sealed class ValueProviderAttribute : Attribute
+  {
+    public ValueProviderAttribute(string name)
+    {
+      Name = name;
+    }
+
+    [NotNull] public string Name { get; private set; }
+  }
+
+  /// <summary>
+  /// Indicates that the function argument should be 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>
+  /// public 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) { ... }
+  ///
+  ///   private 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(string parameterName)
+    {
+      ParameterName = parameterName;
+    }
+
+    public string ParameterName { get; private set; }
+  }
+
+  /// <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 method has single input parameter, it's name could be omitted.<br/>
+  /// Using <c>halt</c> (or <c>void</c>/<c>nothing</c>, which is the same)
+  /// for method output means that the methos doesn't return normally.<br/>
+  /// <c>canbenull</c> annotation 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 semicolon.<br/>
+  /// </syntax>
+  /// <examples><list>
+  /// <item><code>
+  /// [ContractAnnotation("=> halt")]
+  /// public void TerminationMethod()
+  /// </code></item>
+  /// <item><code>
+  /// [ContractAnnotation("halt &lt;= condition: false")]
+  /// public void Assert(bool condition, string text) // regular assertion method
+  /// </code></item>
+  /// <item><code>
+  /// [ContractAnnotation("s:null => 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 => null; notnull => notnull")]
+  /// public object Transform(object data) 
+  /// </code></item>
+  /// <item><code>
+  /// [ContractAnnotation("s:null=>false; =>true,result:notnull; =>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;
+    }
+
+    public string Contract { get; private set; }
+    public bool ForceFullStates { get; private set; }
+  }
+
+  /// <summary>
+  /// Indicates that marked element should be localized or not.
+  /// </summary>
+  /// <example><code>
+  /// [LocalizationRequiredAttribute(true)]
+  /// public class Foo {
+  ///   private 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; private set; }
+  }
+
+  /// <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 {
+  ///   public 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
+  /// public class ComponentAttribute : Attribute { }
+  /// [Component] // ComponentAttribute requires implementing IComponent interface
+  /// public 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; private set; }
+  }
+
+  /// <summary>
+  /// Indicates that the marked symbol is used implicitly (e.g. via reflection, in external library),
+  /// so this symbol will not be marked as unused (as well as by other usage inspections).
+  /// </summary>
+  [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; private set; }
+    public ImplicitUseTargetFlags TargetFlags { get; private set; }
+  }
+
+  /// <summary>
+  /// Should be used on attributes and causes ReSharper to not mark symbols marked with such attributes
+  /// as unused (as well as by other usage inspections)
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Class | AttributeTargets.GenericParameter)]
+  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; private set; }
+    [UsedImplicitly] public ImplicitUseTargetFlags TargetFlags { get; private set; }
+  }
+
+  [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>
+  /// Specify what is considered used implicitly when marked
+  /// with <see cref="MeansImplicitUseAttribute"/> or <see cref="UsedImplicitlyAttribute"/>.
+  /// </summary>
+  [Flags]
+  public enum ImplicitUseTargetFlags
+  {
+    Default = Itself,
+    Itself = 1,
+    /// <summary>Members of entity marked with attribute are considered used.</summary>
+    Members = 2,
+    /// <summary>Entity marked with 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)]
+  public sealed class PublicAPIAttribute : Attribute
+  {
+    public PublicAPIAttribute() { }
+    public PublicAPIAttribute([NotNull] string comment)
+    {
+      Comment = comment;
+    }
+
+    public string Comment { get; private set; }
+  }
+
+  /// <summary>
+  /// Tells code analysis engine if the parameter is completely handled when the invoked method is on stack.
+  /// If the parameter is a delegate, indicates that delegate is executed while the method is executed.
+  /// If the parameter is an enumerable, indicates that it is enumerated while the method is executed.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter)]
+  public sealed class InstantHandleAttribute : Attribute { }
+
+  /// <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] private int Multiply(int x, int y) { return x * y; }
+  /// public void Foo() {
+  ///   const int a = 2, b = 2;
+  ///   Multiply(a, b); // Waring: Return value of pure method is not used
+  /// }
+  /// </code></example>
+  [AttributeUsage(AttributeTargets.Method)]
+  public sealed class PureAttribute : 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([PathReference] string basePath)
+    {
+      BasePath = basePath;
+    }
+
+    public string BasePath { get; private set; }
+  }
+
+  /// <summary>
+  /// An extension method marked with this attribute is processed by ReSharper code completion
+  /// as a 'Source Template'. When extension method is completed over some expression, it's 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>
+    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>
+    public string Target { get; set; }
+  }
+
+  [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+  public sealed class AspMvcAreaMasterLocationFormatAttribute : Attribute
+  {
+    public AspMvcAreaMasterLocationFormatAttribute(string format)
+    {
+      Format = format;
+    }
+
+    public string Format { get; private set; }
+  }
+
+  [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+  public sealed class AspMvcAreaPartialViewLocationFormatAttribute : Attribute
+  {
+    public AspMvcAreaPartialViewLocationFormatAttribute(string format)
+    {
+      Format = format;
+    }
+
+    public string Format { get; private set; }
+  }
+
+  [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+  public sealed class AspMvcAreaViewLocationFormatAttribute : Attribute
+  {
+    public AspMvcAreaViewLocationFormatAttribute(string format)
+    {
+      Format = format;
+    }
+
+    public string Format { get; private set; }
+  }
+
+  [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+  public sealed class AspMvcMasterLocationFormatAttribute : Attribute
+  {
+    public AspMvcMasterLocationFormatAttribute(string format)
+    {
+      Format = format;
+    }
+
+    public string Format { get; private set; }
+  }
+
+  [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+  public sealed class AspMvcPartialViewLocationFormatAttribute : Attribute
+  {
+    public AspMvcPartialViewLocationFormatAttribute(string format)
+    {
+      Format = format;
+    }
+
+    public string Format { get; private set; }
+  }
+
+  [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+  public sealed class AspMvcViewLocationFormatAttribute : Attribute
+  {
+    public AspMvcViewLocationFormatAttribute(string format)
+    {
+      Format = format;
+    }
+
+    public string Format { get; private set; }
+  }
+
+  /// <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)]
+  public sealed class AspMvcActionAttribute : Attribute
+  {
+    public AspMvcActionAttribute() { }
+    public AspMvcActionAttribute(string anonymousProperty)
+    {
+      AnonymousProperty = anonymousProperty;
+    }
+
+    public string AnonymousProperty { get; private set; }
+  }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. Indicates that a 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)]
+  public sealed class AspMvcAreaAttribute : Attribute
+  {
+    public AspMvcAreaAttribute() { }
+    public AspMvcAreaAttribute(string anonymousProperty)
+    {
+      AnonymousProperty = anonymousProperty;
+    }
+
+    public string AnonymousProperty { get; private set; }
+  }
+
+  /// <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)]
+  public sealed class AspMvcControllerAttribute : Attribute
+  {
+    public AspMvcControllerAttribute() { }
+    public AspMvcControllerAttribute(string anonymousProperty)
+    {
+      AnonymousProperty = anonymousProperty;
+    }
+
+    public string AnonymousProperty { get; private set; }
+  }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. Indicates that a 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)]
+  public sealed class AspMvcMasterAttribute : Attribute { }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. Indicates that a 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)]
+  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 AspMvcSupressViewErrorAttribute : 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)]
+  public sealed class AspMvcDisplayTemplateAttribute : Attribute { }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. Indicates that a 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)]
+  public sealed class AspMvcEditorTemplateAttribute : Attribute { }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. Indicates that a 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)]
+  public sealed class AspMvcTemplateAttribute : Attribute { }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
+  /// is an MVC view. 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)]
+  public sealed class AspMvcViewAttribute : 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(string name)
+    {
+      Name = name;
+    }
+
+    public string Name { get; private set; }
+  }
+
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
+  public sealed class HtmlAttributeValueAttribute : Attribute
+  {
+    public HtmlAttributeValueAttribute([NotNull] string name)
+    {
+      Name = name;
+    }
+
+    [NotNull] public string Name { get; private set; }
+  }
+
+  /// <summary>
+  /// Razor attribute. Indicates that a parameter or a 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 invocation affects content of the collection.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Method)]
+  public sealed class CollectionAccessAttribute : Attribute
+  {
+    public CollectionAccessAttribute(CollectionAccessType collectionAccessType)
+    {
+      CollectionAccessType = collectionAccessType;
+    }
+
+    public CollectionAccessType CollectionAccessType { get; private set; }
+  }
+
+  [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 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; private set; }
+  }
+
+  /// <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 method is pure LINQ method, with postponed enumeration (like Enumerable.Select,
+  /// .Where). This annotation allows inference of [InstantHandle] annotation for parameters
+  /// of delegate type by analyzing LINQ method chains.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Method)]
+  public sealed class LinqTunnelAttribute : Attribute { }
+
+  /// <summary>
+  /// Indicates that IEnumerable, passed as parameter, is not enumerated.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter)]
+  public sealed class NoEnumerationAttribute : Attribute { }
+
+  /// <summary>
+  /// Indicates that parameter is regular expression pattern.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter)]
+  public sealed class RegexPatternAttribute : 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 attibute. 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 { }
+
+  [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
+  public sealed class AspChildControlTypeAttribute : Attribute
+  {
+    public AspChildControlTypeAttribute(string tagName, Type controlType)
+    {
+      TagName = tagName;
+      ControlType = controlType;
+    }
+
+    public string TagName { get; private set; }
+    public Type ControlType { get; private set; }
+  }
+
+  [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;
+    }
+
+    public string Attribute { get; private set; }
+  }
+
+  [AttributeUsage(AttributeTargets.Property)]
+  public sealed class AspTypePropertyAttribute : Attribute
+  {
+    public bool CreateConstructorReferences { get; private set; }
+
+    public AspTypePropertyAttribute(bool createConstructorReferences)
+    {
+      CreateConstructorReferences = createConstructorReferences;
+    }
+  }
+
+  [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+  public sealed class RazorImportNamespaceAttribute : Attribute
+  {
+    public RazorImportNamespaceAttribute(string name)
+    {
+      Name = name;
+    }
+
+    public string Name { get; private set; }
+  }
+
+  [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+  public sealed class RazorInjectionAttribute : Attribute
+  {
+    public RazorInjectionAttribute(string type, string fieldName)
+    {
+      Type = type;
+      FieldName = fieldName;
+    }
+
+    public string Type { get; private set; }
+    public string FieldName { get; private set; }
+  }
+
+  [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>
+  /// 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.All)]
+  public sealed class NoReorder : Attribute { }
+}
--- a/Filtration.ObjectModel/Properties/AssemblyInfo.cs
+++ b/Filtration.ObjectModel/Properties/AssemblyInfo.cs
@ -0,0 +1,35 @@
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Filtration.ObjectModel")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("Microsoft")]
+[assembly: AssemblyProduct("Filtration.ObjectModel")]
+[assembly: AssemblyCopyright("Copyright © Microsoft 2015")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("1b4dc4e6-68eb-4586-8570-63e9196fb1de")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
--- a/Filtration.ObjectModel/ReplaceColorsParameterSet.cs
+++ b/Filtration.ObjectModel/ReplaceColorsParameterSet.cs
@ -1,8 +1,8 @@
 using System.Windows.Media;

-namespace Filtration.Models
+namespace Filtration.ObjectModel
 {
-    internal class ReplaceColorsParameterSet
+    public class ReplaceColorsParameterSet
    {
        public Color OldTextColor { get; set; }
        public Color NewTextColor { get; set; }
--- a/Filtration.Tests/Filtration.Tests.csproj
+++ b/Filtration.Tests/Filtration.Tests.csproj
@ -46,9 +46,6 @@
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
-    <Compile Include="Models\TestItemFilterBlock.cs" />
-    <Compile Include="Models\TestItemFilterBlockGroup.cs" />
-    <Compile Include="Models\TestItemFilterScript.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="Repositories\TestItemFilterScriptRepository.cs" />
    <Compile Include="Services\TestItemFilterPersistenceService.cs" />
@ -61,9 +58,14 @@
    <None Include="packages.config" />
  </ItemGroup>
  <ItemGroup>
+    <Folder Include="Models\" />
    <Folder Include="ViewModels\" />
  </ItemGroup>
  <ItemGroup>
+    <ProjectReference Include="..\Filtration.ObjectModel\Filtration.ObjectModel.csproj">
+      <Project>{4aac3beb-1dc1-483e-9d11-0e9334e80227}</Project>
+      <Name>Filtration.ObjectModel</Name>
+    </ProjectReference>
    <ProjectReference Include="..\Filtration\Filtration.csproj">
      <Project>{55e0a34c-e039-43d7-a024-a4045401cdda}</Project>
      <Name>Filtration</Name>
--- a/Filtration.Tests/Properties/AssemblyInfo.cs
+++ b/Filtration.Tests/Properties/AssemblyInfo.cs
@ -1,5 +1,4 @@
 using System.Reflection;
-using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;

 // General Information about an assembly is controlled through the following 
--- a/Filtration.Tests/Repositories/TestItemFilterScriptRepository.cs
+++ b/Filtration.Tests/Repositories/TestItemFilterScriptRepository.cs
@ -1,9 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using System.IO;
 using Filtration.Repositories;
 using Filtration.Services;
 using Filtration.ViewModels;
--- a/Filtration.Tests/Services/TestItemFilterPersistenceService.cs
+++ b/Filtration.Tests/Services/TestItemFilterPersistenceService.cs
@ -1,5 +1,5 @@
 using System.IO;
-using Filtration.Models;
+using Filtration.ObjectModel;
 using Filtration.Services;
 using Filtration.Translators;
 using Moq;
@ -75,7 +75,7 @@ namespace Filtration.Tests.Services
            var service = new ItemFilterPersistenceService(mockFileSystemService.Object, mockItemFilterScriptTranslator.Object);

            // Act
-            var result = service.DefaultPathOfExileDirectory();
+            service.DefaultPathOfExileDirectory();

            // Assert
            mockFileSystemService.Verify();
--- a/Filtration.Tests/Translators/TestItemFilterBlockTranslator.cs
+++ b/Filtration.Tests/Translators/TestItemFilterBlockTranslator.cs
@ -2,10 +2,10 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Windows.Media;
-using Filtration.Enums;
-using Filtration.Models;
-using Filtration.Models.BlockItemBaseTypes;
-using Filtration.Models.BlockItemTypes;
+using Filtration.ObjectModel;
+using Filtration.ObjectModel.BlockItemBaseTypes;
+using Filtration.ObjectModel.BlockItemTypes;
+using Filtration.ObjectModel.Enums;
 using Filtration.Translators;
 using Moq;
 using NUnit.Framework;
@ -49,7 +49,7 @@ namespace Filtration.Tests.Translators

            // Act
            _testUtility.MockBlockGroupHierarchyBuilder.Setup(b => b.IntegrateStringListIntoBlockGroupHierarchy(It.IsAny<IEnumerable<string>>())).Returns(inputBlockGroup).Verifiable();
-            var result = _testUtility.Translator.TranslateStringToItemFilterBlock(inputString);
+            _testUtility.Translator.TranslateStringToItemFilterBlock(inputString);

            // Assert
            _testUtility.MockBlockGroupHierarchyBuilder.Verify();
@ -93,7 +93,7 @@ namespace Filtration.Tests.Translators

            // Act
            _testUtility.MockBlockGroupHierarchyBuilder.Setup(b => b.IntegrateStringListIntoBlockGroupHierarchy(It.IsAny<IEnumerable<string>>())).Verifiable();
-            var result = _testUtility.Translator.TranslateStringToItemFilterBlock(inputString);
+            _testUtility.Translator.TranslateStringToItemFilterBlock(inputString);

            // Assert
            _testUtility.MockBlockGroupHierarchyBuilder.Verify(b => b.IntegrateStringListIntoBlockGroupHierarchy(It.IsAny<IEnumerable<string>>()), Times.Never);
@ -107,7 +107,7 @@ namespace Filtration.Tests.Translators

            // Act
            _testUtility.MockBlockGroupHierarchyBuilder.Setup(b => b.IntegrateStringListIntoBlockGroupHierarchy(It.IsAny<IEnumerable<string>>())).Verifiable();
-            var result = _testUtility.Translator.TranslateStringToItemFilterBlock(inputString);
+            _testUtility.Translator.TranslateStringToItemFilterBlock(inputString);

            // Assert
            _testUtility.MockBlockGroupHierarchyBuilder.Verify(b => b.IntegrateStringListIntoBlockGroupHierarchy(It.IsAny<IEnumerable<string>>()), Times.Never);
@ -1211,7 +1211,7 @@ namespace Filtration.Tests.Translators
        public void TranslateItemFilterBlockToString_Section_ReturnsCorrectString()
        {
            // Arrange
-            var TestInputSectionText = "Ermagerd it's a section!";
+            const string TestInputSectionText = "Ermagerd it's a section!";
            var expectedResult = "# Section: " + TestInputSectionText;

            _testUtility.TestBlock = new ItemFilterSection { Description = TestInputSectionText };
@ -1233,14 +1233,14 @@ namespace Filtration.Tests.Translators
                                 "    DropLevel != 56" + Environment.NewLine +
                                 "    Quality > 2" + Environment.NewLine +
                                 "    Rarity = Unique" + Environment.NewLine +
-                                 "    Class \"Body Armour\" \"Gloves\" \"Belt\" \"Two Hand Axes\"" + Environment.NewLine +
-                                 "    BaseType \"Greater Life Flask\" \"Simple Robe\" \"Full Wyrmscale\"" +
-                                 Environment.NewLine +
                                 "    Sockets <= 6" + Environment.NewLine +
                                 "    LinkedSockets >= 4" + Environment.NewLine +
                                 "    Width = 3" + Environment.NewLine +
                                 "    Height <= 6" + Environment.NewLine +
                                 "    Height >= 2" + Environment.NewLine +
+                                 "    Class \"Body Armour\" \"Gloves\" \"Belt\" \"Two Hand Axes\"" + Environment.NewLine +
+                                 "    BaseType \"Greater Life Flask\" \"Simple Robe\" \"Full Wyrmscale\"" +
+                                 Environment.NewLine +
                                 "    SetTextColor 255 89 0 56" + Environment.NewLine +
                                 "    SetBackgroundColor 0 0 0" + Environment.NewLine +
                                 "    SetBorderColor 255 1 254" + Environment.NewLine +
--- a/Filtration.Tests/Translators/TestItemFilterScriptTranslator.cs
+++ b/Filtration.Tests/Translators/TestItemFilterScriptTranslator.cs
@ -1,9 +1,9 @@
 using System;
 using System.IO;
 using System.Linq;
-using Filtration.Enums;
-using Filtration.Models;
-using Filtration.Models.BlockItemTypes;
+using Filtration.ObjectModel;
+using Filtration.ObjectModel.BlockItemTypes;
+using Filtration.ObjectModel.Enums;
 using Filtration.Translators;
 using Moq;
 using NUnit.Framework;
@ -71,7 +71,7 @@ namespace Filtration.Tests.Translators
            var translator = new ItemFilterScriptTranslator(blockTranslator, mockBlockGroupHierarchyBuilder.Object);

            // Act
-            var script = translator.TranslateStringToItemFilterScript(testInput);
+            translator.TranslateStringToItemFilterScript(testInput);
            // Assert
            // Not crashing out when loading a huge script means this integration test has passed!
        }
@ -85,7 +85,7 @@ namespace Filtration.Tests.Translators
            var testBlock = new ItemFilterBlock();
            testBlock.BlockItems.Add(new ItemLevelBlockItem(FilterPredicateOperator.Equal, 5));

-            var BlockOutput = "Test Script Output";
+            const string BlockOutput = "Test Script Output";

            testScript.ItemFilterBlocks.Add(testBlock);

@ -93,7 +93,7 @@ namespace Filtration.Tests.Translators


            // Act
-            var result = _testUtility.ScriptTranslator.TranslateItemFilterScriptToString(testScript);
+            _testUtility.ScriptTranslator.TranslateItemFilterScriptToString(testScript);

            // Assert
            _testUtility.MockItemFilterBlockTranslator.Verify();
--- a/Filtration.sln
+++ b/Filtration.sln
@ -7,6 +7,10 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Filtration", "Filtration\Fi
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Filtration.Tests", "Filtration.Tests\Filtration.Tests.csproj", "{E0693972-72C5-4E05-A9C5-A5943E4015C6}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Filtration.ObjectModel", "Filtration.ObjectModel\Filtration.ObjectModel.csproj", "{4AAC3BEB-1DC1-483E-9D11-0E9334E80227}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Filtration.ObjectModel.Tests", "Filtration.ObjectModel.Tests\Filtration.ObjectModel.Tests.csproj", "{537BE676-2FF6-4995-B05B-9CFACE852EC9}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@ -21,6 +25,14 @@ Global
 		{E0693972-72C5-4E05-A9C5-A5943E4015C6}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{E0693972-72C5-4E05-A9C5-A5943E4015C6}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{E0693972-72C5-4E05-A9C5-A5943E4015C6}.Release|Any CPU.Build.0 = Release|Any CPU
+		{4AAC3BEB-1DC1-483E-9D11-0E9334E80227}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{4AAC3BEB-1DC1-483E-9D11-0E9334E80227}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{4AAC3BEB-1DC1-483E-9D11-0E9334E80227}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{4AAC3BEB-1DC1-483E-9D11-0E9334E80227}.Release|Any CPU.Build.0 = Release|Any CPU
+		{537BE676-2FF6-4995-B05B-9CFACE852EC9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{537BE676-2FF6-4995-B05B-9CFACE852EC9}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{537BE676-2FF6-4995-B05B-9CFACE852EC9}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{537BE676-2FF6-4995-B05B-9CFACE852EC9}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
--- a/Filtration/App.xaml.cs
+++ b/Filtration/App.xaml.cs
@ -1,15 +1,8 @@
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.Linq;
-using System.Runtime.InteropServices.ComTypes;
+using System.Linq;
 using System.Windows;
-using AutoMapper;
 using Castle.MicroKernel.ModelBuilder.Inspectors;
 using Castle.Windsor;
 using Castle.Windsor.Installer;
-using Filtration.Models;
-using Filtration.Utilities;
-using Filtration.ViewModels;
 using Filtration.Views;

 namespace Filtration
@ -31,65 +24,10 @@ namespace Filtration

            _container.Install(FromAssembly.This());

-
-            // TODO: Find out how to parameterise this to map differently depending if ShowAdvanced is true or false.
-            //Mapper.CreateMap<ItemFilterBlockGroup, ItemFilterBlockGroupViewModel>()
-            //    .ForMember(dest => dest.IsChecked,
-            //        opts => opts.MapFrom(from => from.IsChecked))
-            //    .ForMember(dest => dest.SourceBlockGroup,
-            //        opts => opts.MapFrom(from => from));
-
-            //Mapper.CreateMap<ItemFilterBlockGroup, ItemFilterBlockGroupViewModel>()
-            //    .ForMember(dest => dest.IsChecked,
-            //        opts => opts.MapFrom(from => from.IsChecked))
-            //    .ForMember(dest => dest.ChildGroups,
-            //        opts => opts.ResolveUsing<ChildGroupsResolver>())
-            //    .ForMember(dest => dest.SourceBlockGroup,
-            //        opts => opts.MapFrom(from => from));
-
-            //.ForMember(dest => dest.ChildGroups,
-            //    opts => opts.Condition(src => src.Advanced == false))
-
-            //opts => opts.ResolveUsing<ItemFilterBlockGroupChildGroupsResolver>())
-
-            //opts => opts.MapFrom(from => from.ChildGroups))
-
-            //Mapper.AssertConfigurationIsValid();
-
            var mainWindow = _container.Resolve<IMainWindow>();
            mainWindow.Show();
        }

-
-        //private class ChildGroupsResolver : ValueResolver<ItemFilterBlockGroup, ItemFilterBlockGroupViewModel>
-        //{
-        //    protected override ItemFilterBlockGroupViewModel ResolveCore(ItemFilterBlockGroup source)
-        //    {
-        //        return !source.Advanced ? Mapper.Map<ItemFilterBlockGroup, ItemFilterBlockGroupViewModel>(source) : null;
-        //    }
-        //}
-
-        //private class ChildGroupsResolver :
-        //    ValueResolver<List<ItemFilterBlockGroup>, ObservableCollection<ItemFilterBlockGroupViewModel>>
-        //{
-        //    protected override ObservableCollection<ItemFilterBlockGroupViewModel> ResolveCore(List<ItemFilterBlockGroup> source)
-        //    {
-        //        var result = new ObservableCollection<ItemFilterBlockGroupViewModel>();
-                
-        //        if (source != null && source.Count > 0)
-        //        {
-                    
-        //            var filteredSource = source.Where(g => g.Advanced == false);
-        //            foreach (var blockGroup in filteredSource)
-        //            {
-        //                result.Add(Mapper.Map<ItemFilterBlockGroup, ItemFilterBlockGroupViewModel>(blockGroup));
-        //            }
-        //        }
-
-        //        return result;
-        //    }
-        //}
-
        protected override void OnExit(ExitEventArgs e)
        {
            _container.Dispose();
--- a/Filtration/Converters/BlockItemTypeToStringConverter.cs
+++ b/Filtration/Converters/BlockItemTypeToStringConverter.cs
@ -1,7 +1,7 @@
 using System;
 using System.Globalization;
 using System.Windows.Data;
-using Filtration.Models;
+using Filtration.ObjectModel;

 namespace Filtration.Converters
 {
--- a/Filtration/Converters/BooleanToBlockActionConverter.cs
+++ b/Filtration/Converters/BooleanToBlockActionConverter.cs
@ -1,7 +1,7 @@
 using System;
 using System.Globalization;
 using System.Windows.Data;
-using Filtration.Enums;
+using Filtration.ObjectModel.Enums;

 namespace Filtration.Converters
 {
--- a/Filtration/Converters/BooleanToBlockActionInverseConverter.cs
+++ b/Filtration/Converters/BooleanToBlockActionInverseConverter.cs
@ -1,7 +1,7 @@
 using System;
 using System.Globalization;
 using System.Windows.Data;
-using Filtration.Enums;
+using Filtration.ObjectModel.Enums;

 namespace Filtration.Converters
 {
--- a/Filtration/Converters/ItemRarityConverter.cs
+++ b/Filtration/Converters/ItemRarityConverter.cs
@ -1,7 +1,7 @@
 using System;
 using System.Globalization;
 using System.Windows.Data;
-using Filtration.Enums;
+using Filtration.ObjectModel.Enums;

 namespace Filtration.Converters
 {
--- a/Filtration/Filtration.csproj
+++ b/Filtration/Filtration.csproj
@ -114,46 +114,8 @@
    <Compile Include="Converters\ItemRarityConverter.cs" />
    <Compile Include="Converters\BooleanVisibilityConverter.cs" />
    <Compile Include="Converters\StringToVisibilityConverter.cs" />
-    <Compile Include="Enums\BlockAction.cs" />
-    <Compile Include="Enums\BlockItemType.cs" />
-    <Compile Include="Enums\FilterPredicateOperator.cs" />
-    <Compile Include="Enums\FilterType.cs" />
-    <Compile Include="Enums\ItemRarity.cs" />
-    <Compile Include="Enums\SocketColor.cs" />
    <Compile Include="Extensions\EnumerationExtension.cs" />
-    <Compile Include="Extensions\EnumHelper.cs" />
    <Compile Include="Extensions\HyperlinkExtensions.cs" />
-    <Compile Include="Models\BlockItemBaseTypes\ActionBlockItem.cs" />
-    <Compile Include="Models\BlockItemBaseTypes\BlockItemBase.cs" />
-    <Compile Include="Models\BlockItemBaseTypes\ColorBlockItem.cs" />
-    <Compile Include="Models\BlockItemBaseTypes\DualIntegerBlockItem.cs" />
-    <Compile Include="Models\BlockItemBaseTypes\IntegerBlockItem.cs" />
-    <Compile Include="Models\BlockItemBaseTypes\NumericFilterPredicateBlockItem.cs" />
-    <Compile Include="Models\BlockItemBaseTypes\StringListBlockItem.cs" />
-    <Compile Include="Models\BlockItemTypes\FontSizeBlockItem.cs" />
-    <Compile Include="Models\BlockItemTypes\SoundBlockItem.cs" />
-    <Compile Include="Models\BlockItemTypes\BorderColorBlockItem.cs" />
-    <Compile Include="Models\BlockItemTypes\BaseTypeBlockItem.cs" />
-    <Compile Include="Models\BlockItemTypes\BackgroundColorBlockItem.cs" />
-    <Compile Include="Models\BlockItemTypes\TextColorBlockItem.cs" />
-    <Compile Include="Models\BlockItemTypes\ClassBlockItem.cs" />
-    <Compile Include="Models\BlockItemTypes\HeightBlockItem.cs" />
-    <Compile Include="Models\BlockItemTypes\WidthBlockItem.cs" />
-    <Compile Include="Models\BlockItemTypes\SocketGroupBlockItem.cs" />
-    <Compile Include="Models\BlockItemTypes\LinkedSocketsBlockItem.cs" />
-    <Compile Include="Models\BlockItemTypes\SocketsBlockItem.cs" />
-    <Compile Include="Models\BlockItemTypes\DropLevelBlockItem.cs" />
-    <Compile Include="Models\BlockItemTypes\RarityBlockItem.cs" />
-    <Compile Include="Models\BlockItemTypes\QualityBlockItem.cs" />
-    <Compile Include="Models\BlockItemTypes\ItemLevelBlockItem.cs" />
-    <Compile Include="Models\IAudioVisualBlockItem.cs" />
-    <Compile Include="Models\ItemFilterBlockGroup.cs" />
-    <Compile Include="Models\ItemFilterBlock.cs" />
-    <Compile Include="Models\IItemFilterBlockItem.cs" />
-    <Compile Include="Models\ItemFilterScript.cs" />
-    <Compile Include="Models\ItemFilterSection.cs" />
-    <Compile Include="Models\NumericFilterPredicate.cs" />
-    <Compile Include="Models\ReplaceColorsParameterSet.cs" />
    <Compile Include="Properties\Annotations.cs" />
    <Compile Include="Repositories\ItemFilterScriptRepository.cs" />
    <Compile Include="Services\FileSystemService.cs" />
@ -431,6 +393,15 @@
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\Filtration.ObjectModel\Filtration.ObjectModel.csproj">
+      <Project>{4aac3beb-1dc1-483e-9d11-0e9334e80227}</Project>
+      <Name>Filtration.ObjectModel</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="Models\" />
+  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <Import Project="$(XamlSpyInstallPath)MSBuild\FirstFloor.XamlSpy.WPF.targets" Condition="'$(XamlSpyInstallPath)' != '' and '$(Configuration)' == 'DEBUG'" />
  <Import Project="..\packages\AutoMapper.3.3.1\tools\AutoMapper.targets" Condition="Exists('..\packages\AutoMapper.3.3.1\tools\AutoMapper.targets')" />
--- a/Filtration/Models/ItemFilterSection.cs
+++ b/Filtration/Models/ItemFilterSection.cs
@ -1,6 +0,0 @@
-namespace Filtration.Models
-{
-    internal class ItemFilterSection : ItemFilterBlock
-    {
-    }
-}
--- a/Filtration/Repositories/ItemFilterScriptRepository.cs
+++ b/Filtration/Repositories/ItemFilterScriptRepository.cs
@ -1,6 +1,6 @@
 using System;
 using System.IO;
-using Filtration.Models;
+using Filtration.ObjectModel;
 using Filtration.Services;
 using Filtration.ViewModels;

--- a/Filtration/Services/ItemFilterPersistenceService.cs
+++ b/Filtration/Services/ItemFilterPersistenceService.cs
@ -1,5 +1,5 @@
 using System.IO;
-using Filtration.Models;
+using Filtration.ObjectModel;
 using Filtration.Translators;

 namespace Filtration.Services
--- a/Filtration/Translators/BlockGroupHierarchyBuilder.cs
+++ b/Filtration/Translators/BlockGroupHierarchyBuilder.cs
@ -1,7 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using Filtration.Models;
+using Filtration.ObjectModel;

 namespace Filtration.Translators
 {
--- a/Filtration/Translators/ItemFilterBlockTranslator.cs
+++ b/Filtration/Translators/ItemFilterBlockTranslator.cs
@ -4,11 +4,11 @@ using System.IO;
 using System.Linq;
 using System.Text.RegularExpressions;
 using System.Windows.Media;
-using Filtration.Enums;
-using Filtration.Extensions;
-using Filtration.Models;
-using Filtration.Models.BlockItemBaseTypes;
-using Filtration.Models.BlockItemTypes;
+using Filtration.ObjectModel;
+using Filtration.ObjectModel.BlockItemBaseTypes;
+using Filtration.ObjectModel.BlockItemTypes;
+using Filtration.ObjectModel.Enums;
+using Filtration.ObjectModel.Extensions;
 using Filtration.Utilities;

 namespace Filtration.Translators
--- a/Filtration/Translators/ItemFilterScriptTranslator.cs
+++ b/Filtration/Translators/ItemFilterScriptTranslator.cs
@ -4,7 +4,7 @@ using System.IO;
 using System.Linq;
 using System.Text.RegularExpressions;
 using Castle.Core.Internal;
-using Filtration.Models;
+using Filtration.ObjectModel;
 using Filtration.Utilities;

 namespace Filtration.Translators
--- a/Filtration/UserControls/NumericFilterPredicateControl.xaml
+++ b/Filtration/UserControls/NumericFilterPredicateControl.xaml
@ -5,9 +5,9 @@
             xmlns:xctk="http://schemas.xceed.com/wpf/xaml/toolkit"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
-             xmlns:enums="clr-namespace:Filtration.Enums"
             xmlns:extensions="clr-namespace:Filtration.Extensions"
             xmlns:userControls="clr-namespace:Filtration.UserControls"
+             xmlns:enums="clr-namespace:Filtration.ObjectModel.Enums;assembly=Filtration.ObjectModel"
             mc:Ignorable="d" 
             d:DataContext="{d:DesignInstance Type=userControls:NumericFilterPredicateControl}">
    <Grid>
--- a/Filtration/UserControls/NumericFilterPredicateControl.xaml.cs
+++ b/Filtration/UserControls/NumericFilterPredicateControl.xaml.cs
@ -2,8 +2,8 @@
 using System.Runtime.CompilerServices;
 using System.Windows;
 using Filtration.Annotations;
-using Filtration.Enums;
-using Filtration.Models;
+using Filtration.ObjectModel;
+using Filtration.ObjectModel.Enums;

 namespace Filtration.UserControls
 {
--- a/Filtration/Utilities/BlockGroupMapper.cs
+++ b/Filtration/Utilities/BlockGroupMapper.cs
@ -1,8 +1,7 @@
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
+using System.Collections.ObjectModel;
 using System.Linq;
 using AutoMapper;
-using Filtration.Models;
+using Filtration.ObjectModel;
 using Filtration.ViewModels;

 namespace Filtration.Utilities
--- a/Filtration/ViewModels/FiltrationViewModelBase.cs
+++ b/Filtration/ViewModels/FiltrationViewModelBase.cs
@ -9,7 +9,6 @@ namespace Filtration.ViewModels
        /// This gives us the ReSharper option to transform an autoproperty into a property with change notification
        /// Also leverages .net 4.5 callermembername attribute
        [NotifyPropertyChangedInvocator]
-
        protected override void RaisePropertyChanged([CallerMemberName]string property = "")
        {
            base.RaisePropertyChanged(property);
--- a/Filtration/ViewModels/ItemFilterBlockGroupViewModel.cs
+++ b/Filtration/ViewModels/ItemFilterBlockGroupViewModel.cs
@ -1,6 +1,6 @@
 using System.Collections.ObjectModel;
 using System.Linq;
-using Filtration.Models;
+using Filtration.ObjectModel;

 namespace Filtration.ViewModels
 {
--- a/Filtration/ViewModels/ItemFilterBlockViewModel.cs
+++ b/Filtration/ViewModels/ItemFilterBlockViewModel.cs
@ -4,9 +4,9 @@ using System.Collections.ObjectModel;
 using System.Collections.Specialized;
 using System.Linq;
 using System.Windows.Media;
-using Filtration.Models;
-using Filtration.Models.BlockItemBaseTypes;
-using Filtration.Models.BlockItemTypes;
+using Filtration.ObjectModel;
+using Filtration.ObjectModel.BlockItemBaseTypes;
+using Filtration.ObjectModel.BlockItemTypes;
 using Filtration.Services;
 using Filtration.Views;
 using GalaSoft.MvvmLight.CommandWpf;
--- a/Filtration/ViewModels/ItemFilterScriptViewModel.cs
+++ b/Filtration/ViewModels/ItemFilterScriptViewModel.cs
@ -8,7 +8,7 @@ using System.Windows;
 using System.Windows.Data;
 using System.Windows.Forms;
 using Castle.Core.Internal;
-using Filtration.Models;
+using Filtration.ObjectModel;
 using Filtration.Services;
 using Filtration.Translators;
 using Filtration.ViewModels.ToolPanes;
--- a/Filtration/ViewModels/ReplaceColorsViewModel.cs
+++ b/Filtration/ViewModels/ReplaceColorsViewModel.cs
@ -1,8 +1,8 @@
 using System.Collections.ObjectModel;
 using System.Linq;
 using System.Windows.Media;
-using Filtration.Models;
-using Filtration.Models.BlockItemTypes;
+using Filtration.ObjectModel;
+using Filtration.ObjectModel.BlockItemTypes;
 using Filtration.Views;
 using GalaSoft.MvvmLight.CommandWpf;
 using Xceed.Wpf.Toolkit;
--- a/Filtration/ViewModels/ToolPanes/ToolViewModel.cs
+++ b/Filtration/ViewModels/ToolPanes/ToolViewModel.cs
@ -26,7 +26,7 @@ namespace Filtration.ViewModels.ToolPanes
                if (_isVisible != value)
                {
                    _isVisible = value;
-                    RaisePropertyChanged("IsVisible");
+                    RaisePropertyChanged();
                }
            }
        }
--- a/Filtration/Views/BlockTemplateSelector.cs
+++ b/Filtration/Views/BlockTemplateSelector.cs
@ -1,6 +1,6 @@
 using System.Windows;
 using System.Windows.Controls;
-using Filtration.Models;
+using Filtration.ObjectModel;
 using Filtration.ViewModels;

 namespace Filtration.Views
--- a/Filtration/Views/ItemFilterBlockDisplaySettingsView.xaml
+++ b/Filtration/Views/ItemFilterBlockDisplaySettingsView.xaml
@ -6,9 +6,9 @@
             xmlns:xctk="http://schemas.xceed.com/wpf/xaml/toolkit"
             xmlns:userControls="clr-namespace:Filtration.UserControls"
             xmlns:viewModels="clr-namespace:Filtration.ViewModels"
-             xmlns:blockItemBaseTypes="clr-namespace:Filtration.Models.BlockItemBaseTypes"
-             xmlns:blockItemTypes="clr-namespace:Filtration.Models.BlockItemTypes"
+             xmlns:blockItembaseTypes="clr-namespace:Filtration.ObjectModel.BlockItemBaseTypes;assembly=Filtration.ObjectModel"
             xmlns:componentModel="clr-namespace:System.ComponentModel;assembly=WindowsBase"
+             xmlns:blockItemTypes="clr-namespace:Filtration.ObjectModel.BlockItemTypes;assembly=Filtration.ObjectModel"
             mc:Ignorable="d" 
             d:DataContext="{d:DesignInstance Type=viewModels:ItemFilterBlockViewModel}"
             d:DesignHeight="120" d:DesignWidth="175">
@ -54,7 +54,7 @@
                        <Setter Property="Margin" Value="0,0,5,0" />
                        <Setter Property="VerticalAlignment" Value="Center" />
                    </Style>
-                    <DataTemplate DataType="{x:Type blockItemBaseTypes:ColorBlockItem}">
+                    <DataTemplate DataType="{x:Type blockItembaseTypes:ColorBlockItem}">
                        <Grid Margin="0,0,0,2">
                            <Grid.ColumnDefinitions>
                                <ColumnDefinition SharedSizeGroup="AudioVisualBlockItemTitleColumn" Width="*"  />
@ -66,7 +66,7 @@
                            <userControls:CrossButton Grid.Column="2" Height="12" Command="{Binding ElementName=SettingsGrid, Path=DataContext.RemoveAudioVisualBlockItemCommand}" CommandParameter="{Binding}" />
                        </Grid>
                    </DataTemplate>
-                    <DataTemplate DataType="{x:Type blockItemBaseTypes:IntegerBlockItem}">
+                    <DataTemplate DataType="{x:Type blockItembaseTypes:IntegerBlockItem}">
                        <Grid Margin="0,0,0,2">
                            <Grid.ColumnDefinitions>
                                <ColumnDefinition SharedSizeGroup="AudioVisualBlockItemTitleColumn" Width="*"  />
--- a/Filtration/Views/ItemFilterBlockView.xaml
+++ b/Filtration/Views/ItemFilterBlockView.xaml
@ -7,10 +7,10 @@
             xmlns:userControls="clr-namespace:Filtration.UserControls"
             xmlns:views="clr-namespace:Filtration.Views"
             xmlns:converters="clr-namespace:Filtration.Converters"
-             xmlns:blockItemBaseTypes="clr-namespace:Filtration.Models.BlockItemBaseTypes"
-             xmlns:blockItemTypes="clr-namespace:Filtration.Models.BlockItemTypes"
-             xmlns:enums="clr-namespace:Filtration.Enums"
             xmlns:extensions="clr-namespace:Filtration.Extensions"
+             xmlns:blockItemBaseTypes="clr-namespace:Filtration.ObjectModel.BlockItemBaseTypes;assembly=Filtration.ObjectModel"
+             xmlns:blockItemTypes="clr-namespace:Filtration.ObjectModel.BlockItemTypes;assembly=Filtration.ObjectModel"
+             xmlns:enums="clr-namespace:Filtration.ObjectModel.Enums;assembly=Filtration.ObjectModel"
             mc:Ignorable="d" 
             d:DataContext="{d:DesignInstance Type=viewModels:ItemFilterBlockViewModel}"
             d:DesignHeight="200" d:DesignWidth="800">
--- a/Filtration/Views/ItemFilterBlockView.xaml.cs
+++ b/Filtration/Views/ItemFilterBlockView.xaml.cs
@ -1,5 +1,5 @@
-using System.Windows.Controls;
-using System.Windows.Input;
+using System.Windows.Input;
+using System.Windows.Media;

 namespace Filtration.Views
 {
@ -12,7 +12,7 @@ namespace Filtration.Views

        private void BlockExpander_OnMouseDoubleClick(object sender, MouseButtonEventArgs e)
        {
-            var originalSource = e.OriginalSource as System.Windows.Media.Visual;
+            var originalSource = e.OriginalSource as Visual;
            if (originalSource != null && originalSource.IsDescendantOf(BlockItemsGrid))
            {
                return;