mikx/Filtration
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge remote-tracking branch 'upstream/master'

Browse Source
This commit is contained in:
GlenCFL
2017-12-07 14:16:47 -05:00
parent fef20ff36a d14e4e9320
commit b98988f0b5
115 changed files with 2927 additions and 1252 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Filtration.ObjectModel/BlockItemBaseTypes/ActionBlockItem.cs
View File

@@ -15,7 +15,7 @@ namespace Filtration.ObjectModel.BlockItemBaseTypes
public BlockAction Action
{
get { return _action; }
get => _action;
set
{
_action = value;
@@ -27,6 +27,8 @@ namespace Filtration.ObjectModel.BlockItemBaseTypes
}
}
public string Comment { get; set; }
public override string OutputText => Action.GetAttributeDescription();
public override string PrefixText => string.Empty;

61
Filtration.ObjectModel/Commands/CommandManager.cs Normal file
View File

@@ -0,0 +1,61 @@
using System.Collections.Generic;
namespace Filtration.ObjectModel.Commands
{
public interface ICommandManager
{
void ExecuteCommand(ICommand command);
void Undo(int undoLevels = 1);
void Redo(int redoLevels = 1);
}
public interface ICommandManagerInternal : ICommandManager
{
void SetScript(IItemFilterScriptInternal layout);
}
internal class CommandManager : ICommandManagerInternal
{
private readonly Stack<IUndoableCommand> _undoCommandStack = new Stack<IUndoableCommand>();
private readonly Stack<IUndoableCommand> _redoCommandStack = new Stack<IUndoableCommand>();
private IItemFilterScriptInternal _itemFilterScript;
public void SetScript(IItemFilterScriptInternal itemFilterScript)
{
_itemFilterScript = itemFilterScript;
}
public void ExecuteCommand(ICommand command)
{
command.Execute();
if (command is IUndoableCommand undoableCommand)
{
_undoCommandStack.Push(undoableCommand);
_redoCommandStack.Clear();
}
_itemFilterScript.SetIsDirty(true);
}
public void Undo(int undoLevels = 1)
{
for (var index = undoLevels; _undoCommandStack.Count > 0 && index > 0; --index)
{
var undoableCommand = _undoCommandStack.Pop();
undoableCommand.Undo();
_redoCommandStack.Push(undoableCommand);
}
_itemFilterScript.SetIsDirty(true);
}
public void Redo(int redoLevels = 1)
{
for (int index = redoLevels; _redoCommandStack.Count > 0 && index > 0; --index)
{
var undoableCommand = _redoCommandStack.Pop();
undoableCommand.Redo();
_undoCommandStack.Push(undoableCommand);
}
_itemFilterScript.SetIsDirty(true);
}
}
}

7
Filtration.ObjectModel/Commands/ICommand.cs Normal file
View File

@@ -0,0 +1,7 @@
namespace Filtration.ObjectModel.Commands
{
public interface ICommand
{
void Execute();
}
}

8
Filtration.ObjectModel/Commands/IUndoableCommand.cs Normal file
View File

@@ -0,0 +1,8 @@
namespace Filtration.ObjectModel.Commands
{
internal interface IUndoableCommand : ICommand
{
void Undo();
void Redo();
}
}

37
Filtration.ObjectModel/Commands/ItemFilterScript/AddBlockCommand.cs Normal file
View File

@@ -0,0 +1,37 @@
using System;
namespace Filtration.ObjectModel.Commands.ItemFilterScript
{
public class AddBlockCommand : IUndoableCommand
{
private readonly IItemFilterScript _itemFilterScript;
private readonly IItemFilterBlockBase _addAfterItemFilterBlock;
private IItemFilterBlock _newItemFilterBlock;
public AddBlockCommand(IItemFilterScript itemFilterScript, IItemFilterBlockBase addAfterItemFilterBlock)
{
_itemFilterScript = itemFilterScript;
_addAfterItemFilterBlock = addAfterItemFilterBlock;
}
public void Execute()
{
_newItemFilterBlock = new ItemFilterBlock(_itemFilterScript);
if (_addAfterItemFilterBlock != null)
{
_itemFilterScript.ItemFilterBlocks.Insert(_itemFilterScript.ItemFilterBlocks.IndexOf(_addAfterItemFilterBlock) + 1, _newItemFilterBlock);
}
else
{
_itemFilterScript.ItemFilterBlocks.Add(_newItemFilterBlock);
}
}
public void Undo()
{
_itemFilterScript.ItemFilterBlocks.Remove(_newItemFilterBlock);
}
public void Redo() => Execute();
}
}

37
Filtration.ObjectModel/Commands/ItemFilterScript/AddCommentBlockCommand.cs Normal file
View File

@@ -0,0 +1,37 @@
using System;
namespace Filtration.ObjectModel.Commands.ItemFilterScript
{
public class AddCommentBlockCommand : IUndoableCommand
{
private readonly IItemFilterScript _itemFilterScript;
private readonly IItemFilterBlockBase _addAfterItemFilterBlock;
private IItemFilterCommentBlock _newItemFilterBlock;
public AddCommentBlockCommand(IItemFilterScript itemFilterScript, IItemFilterBlockBase addAfterItemFilterBlock)
{
_itemFilterScript = itemFilterScript;
_addAfterItemFilterBlock = addAfterItemFilterBlock;
}
public void Execute()
{
_newItemFilterBlock = new ItemFilterCommentBlock(_itemFilterScript);
if (_addAfterItemFilterBlock != null)
{
_itemFilterScript.ItemFilterBlocks.Insert(_itemFilterScript.ItemFilterBlocks.IndexOf(_addAfterItemFilterBlock) + 1, _newItemFilterBlock);
}
else
{
_itemFilterScript.ItemFilterBlocks.Add(_newItemFilterBlock);
}
}
public void Undo()
{
_itemFilterScript.ItemFilterBlocks.Remove(_newItemFilterBlock);
}
public void Redo() => Execute();
}
}

39
Filtration.ObjectModel/Commands/ItemFilterScript/MoveBlockDownCommand.cs Normal file
View File

@@ -0,0 +1,39 @@
using System;
namespace Filtration.ObjectModel.Commands.ItemFilterScript
{
public class MoveBlockDownCommand : IUndoableCommand
{
private readonly IItemFilterScript _itemFilterScript;
private readonly IItemFilterBlockBase _blockToMove;
private int _indexMovedFrom;
public MoveBlockDownCommand(IItemFilterScript itemFilterScript, IItemFilterBlockBase blockToMove)
{
_itemFilterScript = itemFilterScript;
_blockToMove = blockToMove;
}
public void Execute()
{
_indexMovedFrom = _itemFilterScript.ItemFilterBlocks.IndexOf(_blockToMove);
if (_indexMovedFrom >= _itemFilterScript.ItemFilterBlocks.Count)
{
throw new InvalidOperationException("Cannot move the bottom block down");
}
_itemFilterScript.ItemFilterBlocks.Remove(_blockToMove);
_itemFilterScript.ItemFilterBlocks.Insert(_indexMovedFrom + 1, _blockToMove);
}
public void Undo()
{
_itemFilterScript.ItemFilterBlocks.Remove(_blockToMove);
_itemFilterScript.ItemFilterBlocks.Insert(_indexMovedFrom, _blockToMove);
}
public void Redo() => Execute();
}
}

30
Filtration.ObjectModel/Commands/ItemFilterScript/MoveBlockToBottomCommand.cs Normal file
View File

@@ -0,0 +1,30 @@
namespace Filtration.ObjectModel.Commands.ItemFilterScript
{
public class MoveBlockToBottomCommand : IUndoableCommand
{
private readonly IItemFilterScript _itemFilterScript;
private readonly IItemFilterBlockBase _blockToMove;
private int _indexMovedFrom;
public MoveBlockToBottomCommand(IItemFilterScript itemFilterScript, IItemFilterBlockBase blockToMove)
{
_itemFilterScript = itemFilterScript;
_blockToMove = blockToMove;
}
public void Execute()
{
_indexMovedFrom = _itemFilterScript.ItemFilterBlocks.IndexOf(_blockToMove);
_itemFilterScript.ItemFilterBlocks.Remove(_blockToMove);
_itemFilterScript.ItemFilterBlocks.Add(_blockToMove);
}
public void Undo()
{
_itemFilterScript.ItemFilterBlocks.Remove(_blockToMove);
_itemFilterScript.ItemFilterBlocks.Insert(_indexMovedFrom, _blockToMove);
}
public void Redo() => Execute();
}
}

30
Filtration.ObjectModel/Commands/ItemFilterScript/MoveBlockToTopCommand.cs Normal file
View File

@@ -0,0 +1,30 @@
namespace Filtration.ObjectModel.Commands.ItemFilterScript
{
public class MoveBlockToTopCommand : IUndoableCommand
{
private readonly IItemFilterScript _itemFilterScript;
private readonly IItemFilterBlockBase _blockToMove;
private int _indexMovedFrom;
public MoveBlockToTopCommand(IItemFilterScript itemFilterScript, IItemFilterBlockBase blockToMove)
{
_itemFilterScript = itemFilterScript;
_blockToMove = blockToMove;
}
public void Execute()
{
_indexMovedFrom = _itemFilterScript.ItemFilterBlocks.IndexOf(_blockToMove);
_itemFilterScript.ItemFilterBlocks.Remove(_blockToMove);
_itemFilterScript.ItemFilterBlocks.Insert(0, _blockToMove);
}
public void Undo()
{
_itemFilterScript.ItemFilterBlocks.Remove(_blockToMove);
_itemFilterScript.ItemFilterBlocks.Insert(_indexMovedFrom, _blockToMove);
}
public void Redo() => Execute();
}
}

39
Filtration.ObjectModel/Commands/ItemFilterScript/MoveBlockUpCommand.cs Normal file
View File

@@ -0,0 +1,39 @@
using System;
namespace Filtration.ObjectModel.Commands.ItemFilterScript
{
public class MoveBlockUpCommand : IUndoableCommand
{
private readonly IItemFilterScript _itemFilterScript;
private readonly IItemFilterBlockBase _blockToMove;
private int _indexMovedFrom;
public MoveBlockUpCommand(IItemFilterScript itemFilterScript, IItemFilterBlockBase blockToMove)
{
_itemFilterScript = itemFilterScript;
_blockToMove = blockToMove;
}
public void Execute()
{
_indexMovedFrom = _itemFilterScript.ItemFilterBlocks.IndexOf(_blockToMove);
if (_indexMovedFrom <= 0)
{
throw new InvalidOperationException("Cannot move the top block up");
}
_itemFilterScript.ItemFilterBlocks.Remove(_blockToMove);
_itemFilterScript.ItemFilterBlocks.Insert(_indexMovedFrom-1, _blockToMove);
}
public void Undo()
{
_itemFilterScript.ItemFilterBlocks.Remove(_blockToMove);
_itemFilterScript.ItemFilterBlocks.Insert(_indexMovedFrom, _blockToMove);
}
public void Redo() => Execute();
}
}

37
Filtration.ObjectModel/Commands/ItemFilterScript/PasteBlockCommand.cs Normal file
View File

@@ -0,0 +1,37 @@
using System;
namespace Filtration.ObjectModel.Commands.ItemFilterScript
{
public class PasteBlockCommand : IUndoableCommand
{
private readonly IItemFilterScript _itemFilterScript;
private readonly IItemFilterBlockBase _pastedItemFilterBlock;
private readonly IItemFilterBlockBase _addAfterItemFilterBlock;
public PasteBlockCommand(IItemFilterScript itemFilterScript, IItemFilterBlockBase pastedItemFilterBlock, IItemFilterBlockBase addAfterItemFilterBlock)
{
_itemFilterScript = itemFilterScript;
_pastedItemFilterBlock = pastedItemFilterBlock;
_addAfterItemFilterBlock = addAfterItemFilterBlock;
}
public void Execute()
{
if (_addAfterItemFilterBlock != null)
{
_itemFilterScript.ItemFilterBlocks.Insert(_itemFilterScript.ItemFilterBlocks.IndexOf(_addAfterItemFilterBlock) + 1, _pastedItemFilterBlock);
}
else
{
_itemFilterScript.ItemFilterBlocks.Add(_pastedItemFilterBlock);
}
}
public void Undo()
{
_itemFilterScript.ItemFilterBlocks.Remove(_pastedItemFilterBlock);
}
public void Redo() => Execute();
}
}

29
Filtration.ObjectModel/Commands/ItemFilterScript/RemoveBlockCommand.cs Normal file
View File

@@ -0,0 +1,29 @@
using System;
namespace Filtration.ObjectModel.Commands.ItemFilterScript
{
public class RemoveBlockCommand : IUndoableCommand
{
private readonly IItemFilterScript _itemFilterScript;
private IItemFilterBlockBase _removedItemFilterBlock;
private int _indexRemovedFrom;
public RemoveBlockCommand(IItemFilterScript itemFilterScript, IItemFilterBlockBase itemFilterBlockBase)
{
_itemFilterScript = itemFilterScript;
_removedItemFilterBlock = itemFilterBlockBase;
}
public void Execute()
{
_indexRemovedFrom = _itemFilterScript.ItemFilterBlocks.IndexOf(_removedItemFilterBlock);
_itemFilterScript.ItemFilterBlocks.Remove(_removedItemFilterBlock);
}
public void Undo()
{
_itemFilterScript.ItemFilterBlocks.Insert(_indexRemovedFrom, _removedItemFilterBlock);
}
public void Redo() => Execute();
}
}

30
Filtration.ObjectModel/Commands/ItemFilterScript/SetScriptDescriptionCommand.cs Normal file
View File

@@ -0,0 +1,30 @@
using System;
namespace Filtration.ObjectModel.Commands.ItemFilterScript
{
public class SetScriptDescriptionCommand : IUndoableCommand
{
private readonly IItemFilterScript _itemFilterScript;
private readonly string _newDescription;
private string _oldDescription;
public SetScriptDescriptionCommand(IItemFilterScript itemFilterScript, string newDescription)
{
_itemFilterScript = itemFilterScript;
_newDescription = newDescription;
}
public void Execute()
{
_oldDescription = _itemFilterScript.Description;
_itemFilterScript.Description = _newDescription;
}
public void Undo()
{
_itemFilterScript.Description = _oldDescription;
}
public void Redo() => Execute();
}
}

9
Filtration.ObjectModel/Factories/IItemFilterScriptFactory.cs Normal file
View File

@@ -0,0 +1,9 @@
namespace Filtration.ObjectModel.Factories
{
public interface IItemFilterScriptFactory
{
IItemFilterScript Create();
void Release(IItemFilterScript itemFilterScript);
}
}

23
Filtration.ObjectModel/Filtration.ObjectModel.csproj
View File

@@ -31,6 +31,12 @@
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<ItemGroup>
<Reference Include="Castle.Core, Version=3.3.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
<HintPath>..\packages\Castle.Core.3.3.0\lib\net45\Castle.Core.dll</HintPath>
</Reference>
<Reference Include="Castle.Windsor, Version=3.4.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
<HintPath>..\packages\Castle.Windsor.3.4.0\lib\net45\Castle.Windsor.dll</HintPath>
</Reference>
<Reference Include="PresentationCore" />
<Reference Include="System" />
<Reference Include="System.ComponentModel.DataAnnotations" />
@@ -73,6 +79,18 @@
<Compile Include="BlockItemTypes\SoundBlockItem.cs" />
<Compile Include="BlockItemTypes\TextColorBlockItem.cs" />
<Compile Include="BlockItemTypes\WidthBlockItem.cs" />
<Compile Include="Commands\CommandManager.cs" />
<Compile Include="Commands\ICommand.cs" />
<Compile Include="Commands\ItemFilterScript\PasteBlockCommand.cs" />
<Compile Include="Commands\ItemFilterScript\MoveBlockToBottomCommand.cs" />
<Compile Include="Commands\ItemFilterScript\AddCommentBlockCommand.cs" />
<Compile Include="Commands\ItemFilterScript\MoveBlockDownCommand.cs" />
<Compile Include="Commands\ItemFilterScript\MoveBlockUpCommand.cs" />
<Compile Include="Commands\ItemFilterScript\MoveBlockToTopCommand.cs" />
<Compile Include="Commands\ItemFilterScript\SetScriptDescriptionCommand.cs" />
<Compile Include="Commands\ItemFilterScript\RemoveBlockCommand.cs" />
<Compile Include="Commands\ItemFilterScript\AddBlockCommand.cs" />
<Compile Include="Commands\IUndoableCommand.cs" />
<Compile Include="Enums\BlockAction.cs" />
<Compile Include="Enums\BlockItemType.cs" />
<Compile Include="Enums\FilterPredicateOperator.cs" />
@@ -82,6 +100,7 @@
<Compile Include="Enums\ThemeComponentType.cs" />
<Compile Include="Extensions\EnumHelper.cs" />
<Compile Include="Extensions\ItemRarityExtensions.cs" />
<Compile Include="Factories\IItemFilterScriptFactory.cs" />
<Compile Include="FilteredItem.cs" />
<Compile Include="IAudioVisualBlockItem.cs" />
<Compile Include="IItemFilterBlockItem.cs" />
@@ -89,7 +108,7 @@
<Compile Include="ItemFilterBlock.cs" />
<Compile Include="ItemFilterBlockGroup.cs" />
<Compile Include="ItemFilterScript.cs" />
<Compile Include="ItemFilterSection.cs" />
<Compile Include="ItemFilterScriptSettings.cs" />
<Compile Include="ItemSet.cs" />
<Compile Include="NumericFilterPredicate.cs" />
<Compile Include="PathOfExileNamedColors.cs" />
@@ -102,6 +121,8 @@
<Compile Include="ThemeEditor\Theme.cs" />
<Compile Include="ThemeEditor\ThemeComponent.cs" />
<Compile Include="ThemeEditor\ThemeComponentCollection.cs" />
<Compile Include="WindsorInstallers\CommandsInstaller.cs" />
<Compile Include="WindsorInstallers\ModelsInstaller.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.

2
Filtration.ObjectModel/IItemFilterBlockItem.cs
View File

@@ -5,8 +5,6 @@ namespace Filtration.ObjectModel
{
public interface IItemFilterBlockItem : INotifyPropertyChanged
{
event PropertyChangedEventHandler PropertyChanged;
string PrefixText { get; }
string OutputText { get; }
string DisplayHeading { get; }

70
Filtration.ObjectModel/ItemFilterBlock.cs
View File

@@ -4,44 +4,82 @@ using System.Linq;
using System.Windows.Media;
using Filtration.ObjectModel.BlockItemBaseTypes;
using Filtration.ObjectModel.BlockItemTypes;
using Filtration.ObjectModel.Commands;
using Filtration.ObjectModel.Enums;
using Filtration.ObjectModel.Extensions;
namespace Filtration.ObjectModel
{
public interface IItemFilterBlock
public interface IItemFilterBlock : IItemFilterBlockBase
{
bool Enabled { get; set; }
string Description { get; set; }
ItemFilterBlockGroup BlockGroup { get; set; }
BlockAction Action { get; set; }
ActionBlockItem ActionBlockItem { get; }
ObservableCollection<IItemFilterBlockItem> BlockItems { get; }
Color DisplayBackgroundColor { get; }
Color DisplayTextColor { get; }
Color DisplayBorderColor { get; }
double DisplayFontSize { get; }
int BlockCount(Type type);
bool AddBlockItemAllowed(Type type);
bool HasBlockItemOfType<T>();
bool HasBlockGroupInParentHierarchy(ItemFilterBlockGroup targetBlockGroup, ItemFilterBlockGroup startingBlockGroup);
}
public class ItemFilterBlock : IItemFilterBlock
public interface IItemFilterBlockBase
{
}
public abstract class ItemFilterBlockBase : IItemFilterBlockBase
{
protected ItemFilterBlockBase()
{
}
protected ItemFilterBlockBase(IItemFilterScript parentScript)
{
CommandManager = parentScript.CommandManager;
ParentScript = parentScript;
}
public ICommandManager CommandManager { get; }
public IItemFilterScript ParentScript { get; set; }
}
public interface IItemFilterCommentBlock : IItemFilterBlockBase
{
string Comment { get; set; }
}
public class ItemFilterCommentBlock : ItemFilterBlockBase, IItemFilterCommentBlock
{
public ItemFilterCommentBlock(IItemFilterScript parentScript) : base(parentScript)
{
}
public string Comment { get; set; }
}
public class ItemFilterBlock : ItemFilterBlockBase, IItemFilterBlock
{
private ItemFilterBlockGroup _blockGroup;
public ItemFilterBlock()
internal ItemFilterBlock()
{
BlockItems = new ObservableCollection<IItemFilterBlockItem> {new ActionBlockItem(BlockAction.Show)};
Enabled = true;
BlockItems = new ObservableCollection<IItemFilterBlockItem> { ActionBlockItem };
}
public bool Enabled { get; set; }
public ItemFilterBlock(IItemFilterScript parentScript) : base(parentScript)
{
BlockItems = new ObservableCollection<IItemFilterBlockItem> { ActionBlockItem };
}
public bool Enabled { get; set; } = true;
public string Description { get; set; }
public ItemFilterBlockGroup BlockGroup
{
get { return _blockGroup; }
get => _blockGroup;
set
{
var oldBlockGroup = _blockGroup;
@@ -79,17 +117,19 @@ namespace Filtration.ObjectModel
}
}
public ObservableCollection<IItemFilterBlockItem> BlockItems { get; }
public ActionBlockItem ActionBlockItem { get; } = new ActionBlockItem(BlockAction.Show);
public int BlockCount(Type type)
{
return BlockItems?.Count(b => b.GetType() == type) ?? 0;
}
public ObservableCollection<IItemFilterBlockItem> BlockItems { get; }
public bool AddBlockItemAllowed(Type type)
{
int BlockCount()
{
return BlockItems?.Count(b => b.GetType() == type) ?? 0;
}
var blockItem = (IItemFilterBlockItem)Activator.CreateInstance(type);
return BlockCount(type) < blockItem.MaximumAllowed;
return BlockCount() < blockItem.MaximumAllowed;
}
public bool HasBlockItemOfType<T>()

95
Filtration.ObjectModel/ItemFilterScript.cs
View File

@@ -1,45 +1,101 @@
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Runtime.CompilerServices;
using Filtration.ObjectModel.Annotations;
using Filtration.ObjectModel.BlockItemTypes;
using Filtration.ObjectModel.Commands;
using Filtration.ObjectModel.ThemeEditor;
namespace Filtration.ObjectModel
{
public interface IItemFilterScript
public interface IItemFilterScript : INotifyPropertyChanged
{
ObservableCollection<IItemFilterBlock> ItemFilterBlocks { get; }
ICommandManager CommandManager { get; }
ObservableCollection<IItemFilterBlockBase> ItemFilterBlocks { get; }
ObservableCollection<ItemFilterBlockGroup> ItemFilterBlockGroups { get; }
ThemeComponentCollection ThemeComponents { get; set; }
string FilePath { get; set; }
string Description { get; set; }
DateTime DateModified { get; set; }
bool IsDirty { get; }
IItemFilterScriptSettings ItemFilterScriptSettings { get; }
List<string> Validate();
void ReplaceColors(ReplaceColorsParameterSet replaceColorsParameterSet);
}
public class ItemFilterScript : IItemFilterScript
public interface IItemFilterScriptInternal : IItemFilterScript
{
public ItemFilterScript()
void SetIsDirty(bool isDirty);
}
public class ItemFilterScript : IItemFilterScriptInternal
{
private bool _isDirty;
private string _description;
internal ItemFilterScript()
{
ItemFilterBlocks = new ObservableCollection<IItemFilterBlock>();
ItemFilterBlocks = new ObservableCollection<IItemFilterBlockBase>();
ItemFilterBlockGroups = new ObservableCollection<ItemFilterBlockGroup>
{
new ItemFilterBlockGroup("Root", null)
};
ThemeComponents = new ThemeComponentCollection { IsMasterCollection = true};
ThemeComponents = new ThemeComponentCollection { IsMasterCollection = true };
ItemFilterScriptSettings = new ItemFilterScriptSettings(ThemeComponents);
}
public ObservableCollection<IItemFilterBlock> ItemFilterBlocks { get; }
public ItemFilterScript(ICommandManagerInternal commandManager) : this()
{
CommandManager = commandManager;
commandManager.SetScript(this);
}
public ICommandManager CommandManager { get; }
public ObservableCollection<IItemFilterBlockBase> ItemFilterBlocks { get; }
public ObservableCollection<ItemFilterBlockGroup> ItemFilterBlockGroups { get; }
public ThemeComponentCollection ThemeComponents { get; set; }
public IItemFilterScriptSettings ItemFilterScriptSettings { get; }
public string FilePath { get; set; }
public string Description { get; set; }
public string Description
{
get => _description;
set
{
if (value == _description) return;
_description = value;
OnPropertyChanged();
}
}
public DateTime DateModified { get; set; }
public bool IsDirty
{
get => _isDirty;
private set
{
if (value == _isDirty) return;
_isDirty = value;
OnPropertyChanged();
}
}
public void SetIsDirty(bool isDirty)
{
IsDirty = isDirty;
}
public List<string> Validate()
{
var validationErrors = new List<string>();
@@ -54,9 +110,7 @@ namespace Filtration.ObjectModel
public void ReplaceColors(ReplaceColorsParameterSet replaceColorsParameterSet)
{
foreach (
var block in
ItemFilterBlocks.Where(b => BlockIsColorReplacementCandidate(replaceColorsParameterSet, b)))
foreach (var block in ItemFilterBlocks.OfType<ItemFilterBlock>().Where(b => BlockIsColorReplacementCandidate(replaceColorsParameterSet, b)))
{
if (replaceColorsParameterSet.ReplaceTextColor)
{
@@ -78,15 +132,9 @@ namespace Filtration.ObjectModel
private bool BlockIsColorReplacementCandidate(ReplaceColorsParameterSet replaceColorsParameterSet, IItemFilterBlock block)
{
var textColorItem = block.HasBlockItemOfType<TextColorBlockItem>()
? block.BlockItems.OfType<TextColorBlockItem>().First()
: null;
var backgroundColorItem = block.HasBlockItemOfType<BackgroundColorBlockItem>()
? block.BlockItems.OfType<BackgroundColorBlockItem>().First()
: null;
var borderColorItem = block.HasBlockItemOfType<BorderColorBlockItem>()
? block.BlockItems.OfType<BorderColorBlockItem>().First()
: null;
var textColorItem = block.BlockItems.OfType<TextColorBlockItem>().FirstOrDefault();
var backgroundColorItem = block.BlockItems.OfType<BackgroundColorBlockItem>().FirstOrDefault();
var borderColorItem = block.BlockItems.OfType<BorderColorBlockItem>().FirstOrDefault();
// If we don't have all of the things we want to replace, then we aren't a candidate for replacing those things.
if ((textColorItem == null && replaceColorsParameterSet.ReplaceTextColor) ||
@@ -109,5 +157,12 @@ namespace Filtration.ObjectModel
return true;
}
public event PropertyChangedEventHandler PropertyChanged;
[NotifyPropertyChangedInvocator]
protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
{
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
}
}

21
Filtration.ObjectModel/ItemFilterScriptSettings.cs Normal file
View File

@@ -0,0 +1,21 @@
using Filtration.ObjectModel.ThemeEditor;
namespace Filtration.ObjectModel
{
public interface IItemFilterScriptSettings
{
bool BlockGroupsEnabled { get; set; }
ThemeComponentCollection ThemeComponentCollection { get; }
}
public class ItemFilterScriptSettings : IItemFilterScriptSettings
{
public ItemFilterScriptSettings(ThemeComponentCollection themeComponentCollection)
{
ThemeComponentCollection = themeComponentCollection;
}
public bool BlockGroupsEnabled { get; set; }
public ThemeComponentCollection ThemeComponentCollection { get; }
}
}

6
Filtration.ObjectModel/ItemFilterSection.cs
View File

@@ -1,6 +0,0 @@
namespace Filtration.ObjectModel
{
public class ItemFilterSection : ItemFilterBlock
{
}
}

295
Filtration.ObjectModel/Properties/Annotations.cs
View File

@@ -1,4 +1,26 @@
using System;
/* MIT License
Copyright (c) 2016 JetBrains http://www.jetbrains.com
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE. */
using System;
#pragma warning disable 1591
// ReSharper disable UnusedMember.Global
@@ -7,7 +29,6 @@
// ReSharper disable IntroduceOptionalParameters.Global
// ReSharper disable MemberCanBeProtected.Global
// ReSharper disable InconsistentNaming
// ReSharper disable CheckNamespace
namespace Filtration.ObjectModel.Annotations
{
@@ -16,32 +37,37 @@ namespace Filtration.ObjectModel.Annotations
/// so the check for <c>null</c> is necessary before its usage.
/// </summary>
/// <example><code>
/// [CanBeNull] public object Test() { return null; }
/// public void UseTest() {
/// [CanBeNull] object Test() => null;
///
/// void UseTest() {
/// var p = Test();
/// var s = p.ToString(); // Warning: Possible 'System.NullReferenceException'
/// }
/// </code></example>
[AttributeUsage(
AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
AttributeTargets.Delegate | AttributeTargets.Field | AttributeTargets.Event)]
AttributeTargets.Delegate | AttributeTargets.Field | AttributeTargets.Event |
AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.GenericParameter)]
public sealed class CanBeNullAttribute : Attribute { }
/// <summary>
/// Indicates that the value of the marked element could never be <c>null</c>.
/// </summary>
/// <example><code>
/// [NotNull] public object Foo() {
/// [NotNull] object Foo() {
/// return null; // Warning: Possible 'null' assignment
/// }
/// </code></example>
[AttributeUsage(
AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
AttributeTargets.Delegate | AttributeTargets.Field | AttributeTargets.Event)]
AttributeTargets.Delegate | AttributeTargets.Field | AttributeTargets.Event |
AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.GenericParameter)]
public sealed class NotNullAttribute : Attribute { }
/// <summary>
/// Indicates that collection or enumerable value does not contain null elements.
/// Can be appplied to symbols of types derived from IEnumerable as well as to symbols of Task
/// and Lazy classes to indicate that the value of a collection item, of the Task.Result property
/// or of the Lazy.Value property can never be null.
/// </summary>
[AttributeUsage(
AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
@@ -49,7 +75,9 @@ namespace Filtration.ObjectModel.Annotations
public sealed class ItemNotNullAttribute : Attribute { }
/// <summary>
/// Indicates that collection or enumerable value can contain null elements.
/// Can be appplied to symbols of types derived from IEnumerable as well as to symbols of Task
/// and Lazy classes to indicate that the value of a collection item, of the Task.Result property
/// or of the Lazy.Value property can be null.
/// </summary>
[AttributeUsage(
AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
@@ -63,8 +91,9 @@ namespace Filtration.ObjectModel.Annotations
/// </summary>
/// <example><code>
/// [StringFormatMethod("message")]
/// public void ShowError(string message, params object[] args) { /* do something */ }
/// public void Foo() {
/// void ShowError(string message, params object[] args) { /* do something */ }
///
/// void Foo() {
/// ShowError("Failed: {0}"); // Warning: Non-existing argument in format string
/// }
/// </code></example>
@@ -76,22 +105,24 @@ namespace Filtration.ObjectModel.Annotations
/// <param name="formatParameterName">
/// Specifies which parameter of an annotated method should be treated as format-string
/// </param>
public StringFormatMethodAttribute(string formatParameterName)
public StringFormatMethodAttribute([NotNull] string formatParameterName)
{
FormatParameterName = formatParameterName;
}
public string FormatParameterName { get; private set; }
[NotNull] 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)]
[AttributeUsage(
AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.Field,
AllowMultiple = true)]
public sealed class ValueProviderAttribute : Attribute
{
public ValueProviderAttribute(string name)
public ValueProviderAttribute([NotNull] string name)
{
Name = name;
}
@@ -105,7 +136,7 @@ namespace Filtration.ObjectModel.Annotations
/// the parameter of <see cref="System.ArgumentNullException"/>.
/// </summary>
/// <example><code>
/// public void Foo(string param) {
/// void Foo(string param) {
/// if (param == null)
/// throw new ArgumentNullException("par"); // Warning: Cannot resolve symbol
/// }
@@ -131,10 +162,12 @@ namespace Filtration.ObjectModel.Annotations
/// <example><code>
/// public class Foo : INotifyPropertyChanged {
/// public event PropertyChangedEventHandler PropertyChanged;
///
/// [NotifyPropertyChangedInvocator]
/// protected virtual void NotifyChanged(string propertyName) { ... }
///
/// private string _name;
/// string _name;
///
/// public string Name {
/// get { return _name; }
/// set { _name = value; NotifyChanged("LastName"); /* Warning */ }
@@ -153,12 +186,12 @@ namespace Filtration.ObjectModel.Annotations
public sealed class NotifyPropertyChangedInvocatorAttribute : Attribute
{
public NotifyPropertyChangedInvocatorAttribute() { }
public NotifyPropertyChangedInvocatorAttribute(string parameterName)
public NotifyPropertyChangedInvocatorAttribute([NotNull] string parameterName)
{
ParameterName = parameterName;
}
public string ParameterName { get; private set; }
[CanBeNull] public string ParameterName { get; private set; }
}
/// <summary>
@@ -174,15 +207,16 @@ namespace Filtration.ObjectModel.Annotations
/// <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/>
/// 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 (throws or terminates the process).<br/>
/// Value <c>canbenull</c> is only applicable for output parameters.<br/>
/// You can use multiple <c>[ContractAnnotation]</c> for each FDT row, or use single attribute
/// with rows separated by semicolon. There is no notion of order rows, all rows are checked
/// for applicability and applied per each program state tracked by R# analysis.<br/>
/// </syntax>
/// <examples><list>
/// <item><code>
/// [ContractAnnotation("=> halt")]
/// [ContractAnnotation("=&gt; halt")]
/// public void TerminationMethod()
/// </code></item>
/// <item><code>
@@ -190,17 +224,17 @@ namespace Filtration.ObjectModel.Annotations
/// public void Assert(bool condition, string text) // regular assertion method
/// </code></item>
/// <item><code>
/// [ContractAnnotation("s:null => true")]
/// [ContractAnnotation("s:null =&gt; true")]
/// public bool IsNullOrEmpty(string s) // string.IsNullOrEmpty()
/// </code></item>
/// <item><code>
/// // A method that returns null if the parameter is null,
/// // and not null if the parameter is not null
/// [ContractAnnotation("null => null; notnull => notnull")]
/// [ContractAnnotation("null =&gt; null; notnull =&gt; notnull")]
/// public object Transform(object data)
/// </code></item>
/// <item><code>
/// [ContractAnnotation("s:null=>false; =>true,result:notnull; =>false, result:null")]
/// [ContractAnnotation("=&gt; true, result: notnull; =&gt; false, result: null")]
/// public bool TryParse(string s, out Person result)
/// </code></item>
/// </list></examples>
@@ -216,7 +250,8 @@ namespace Filtration.ObjectModel.Annotations
ForceFullStates = forceFullStates;
}
public string Contract { get; private set; }
[NotNull] public string Contract { get; private set; }
public bool ForceFullStates { get; private set; }
}
@@ -225,14 +260,15 @@ namespace Filtration.ObjectModel.Annotations
/// </summary>
/// <example><code>
/// [LocalizationRequiredAttribute(true)]
/// public class Foo {
/// private string str = "my string"; // Warning: Localizable string
/// class Foo {
/// string str = "my string"; // Warning: Localizable string
/// }
/// </code></example>
[AttributeUsage(AttributeTargets.All)]
public sealed class LocalizationRequiredAttribute : Attribute
{
public LocalizationRequiredAttribute() : this(true) { }
public LocalizationRequiredAttribute(bool required)
{
Required = required;
@@ -250,8 +286,9 @@ namespace Filtration.ObjectModel.Annotations
/// <example><code>
/// [CannotApplyEqualityOperator]
/// class NoEquality { }
///
/// class UsesNoEquality {
/// public void Test() {
/// void Test() {
/// var ca1 = new NoEquality();
/// var ca2 = new NoEquality();
/// if (ca1 != null) { // OK
@@ -269,9 +306,10 @@ namespace Filtration.ObjectModel.Annotations
/// </summary>
/// <example><code>
/// [BaseTypeRequired(typeof(IComponent)] // Specify requirement
/// public class ComponentAttribute : Attribute { }
/// class ComponentAttribute : Attribute { }
///
/// [Component] // ComponentAttribute requires implementing IComponent interface
/// public class MyComponent : IComponent { }
/// class MyComponent : IComponent { }
/// </code></example>
[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
[BaseTypeRequired(typeof(Attribute))]
@@ -308,6 +346,7 @@ namespace Filtration.ObjectModel.Annotations
}
public ImplicitUseKindFlags UseKindFlags { get; private set; }
public ImplicitUseTargetFlags TargetFlags { get; private set; }
}
@@ -334,6 +373,7 @@ namespace Filtration.ObjectModel.Annotations
}
[UsedImplicitly] public ImplicitUseKindFlags UseKindFlags { get; private set; }
[UsedImplicitly] public ImplicitUseTargetFlags TargetFlags { get; private set; }
}
@@ -377,12 +417,13 @@ namespace Filtration.ObjectModel.Annotations
public sealed class PublicAPIAttribute : Attribute
{
public PublicAPIAttribute() { }
public PublicAPIAttribute([NotNull] string comment)
{
Comment = comment;
}
public string Comment { get; private set; }
[CanBeNull] public string Comment { get; private set; }
}
/// <summary>
@@ -398,15 +439,51 @@ namespace Filtration.ObjectModel.Annotations
/// 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
/// [Pure] int Multiply(int x, int y) => x * y;
///
/// void M() {
/// Multiply(123, 42); // Waring: Return value of pure method is not used
/// }
/// </code></example>
[AttributeUsage(AttributeTargets.Method)]
public sealed class PureAttribute : Attribute { }
/// <summary>
/// Indicates that the return value of method invocation must be used.
/// </summary>
[AttributeUsage(AttributeTargets.Method)]
public sealed class MustUseReturnValueAttribute : Attribute
{
public MustUseReturnValueAttribute() { }
public MustUseReturnValueAttribute([NotNull] string justification)
{
Justification = justification;
}
[CanBeNull] public string Justification { get; private set; }
}
/// <summary>
/// Indicates the type member or parameter of some type, that should be used instead of all other ways
/// to get the value that type. This annotation is useful when you have some "context" value evaluated
/// and stored somewhere, meaning that all other ways to get this value must be consolidated with existing one.
/// </summary>
/// <example><code>
/// class Foo {
/// [ProvidesContext] IBarService _barService = ...;
///
/// void ProcessNode(INode node) {
/// DoSomething(node, node.GetGlobalServices().Bar);
/// // ^ Warning: use value of '_barService' field
/// }
/// }
/// </code></example>
[AttributeUsage(
AttributeTargets.Field | AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.Method |
AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.Struct | AttributeTargets.GenericParameter)]
public sealed class ProvidesContextAttribute : Attribute { }
/// <summary>
/// Indicates that a parameter is a path to a file or a folder within a web project.
/// Path can be relative or absolute, starting from web root (~).
@@ -415,12 +492,13 @@ namespace Filtration.ObjectModel.Annotations
public sealed class PathReferenceAttribute : Attribute
{
public PathReferenceAttribute() { }
public PathReferenceAttribute([PathReference] string basePath)
public PathReferenceAttribute([NotNull, PathReference] string basePath)
{
BasePath = basePath;
}
public string BasePath { get; private set; }
[CanBeNull] public string BasePath { get; private set; }
}
/// <summary>
@@ -484,7 +562,7 @@ namespace Filtration.ObjectModel.Annotations
/// 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; }
[CanBeNull] public string Expression { get; set; }
/// <summary>
/// Allows specifying which occurrence of the target parameter becomes editable when the template is deployed.
@@ -500,73 +578,73 @@ namespace Filtration.ObjectModel.Annotations
/// 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; }
[CanBeNull] public string Target { get; set; }
}
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = true)]
public sealed class AspMvcAreaMasterLocationFormatAttribute : Attribute
{
public AspMvcAreaMasterLocationFormatAttribute(string format)
public AspMvcAreaMasterLocationFormatAttribute([NotNull] string format)
{
Format = format;
}
public string Format { get; private set; }
[NotNull] public string Format { get; private set; }
}
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = true)]
public sealed class AspMvcAreaPartialViewLocationFormatAttribute : Attribute
{
public AspMvcAreaPartialViewLocationFormatAttribute(string format)
public AspMvcAreaPartialViewLocationFormatAttribute([NotNull] string format)
{
Format = format;
}
public string Format { get; private set; }
[NotNull] public string Format { get; private set; }
}
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = true)]
public sealed class AspMvcAreaViewLocationFormatAttribute : Attribute
{
public AspMvcAreaViewLocationFormatAttribute(string format)
public AspMvcAreaViewLocationFormatAttribute([NotNull] string format)
{
Format = format;
}
public string Format { get; private set; }
[NotNull] public string Format { get; private set; }
}
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = true)]
public sealed class AspMvcMasterLocationFormatAttribute : Attribute
{
public AspMvcMasterLocationFormatAttribute(string format)
public AspMvcMasterLocationFormatAttribute([NotNull] string format)
{
Format = format;
}
public string Format { get; private set; }
[NotNull] public string Format { get; private set; }
}
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = true)]
public sealed class AspMvcPartialViewLocationFormatAttribute : Attribute
{
public AspMvcPartialViewLocationFormatAttribute(string format)
public AspMvcPartialViewLocationFormatAttribute([NotNull] string format)
{
Format = format;
}
public string Format { get; private set; }
[NotNull] public string Format { get; private set; }
}
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = true)]
public sealed class AspMvcViewLocationFormatAttribute : Attribute
{
public AspMvcViewLocationFormatAttribute(string format)
public AspMvcViewLocationFormatAttribute([NotNull] string format)
{
Format = format;
}
public string Format { get; private set; }
[NotNull] public string Format { get; private set; }
}
/// <summary>
@@ -579,12 +657,13 @@ namespace Filtration.ObjectModel.Annotations
public sealed class AspMvcActionAttribute : Attribute
{
public AspMvcActionAttribute() { }
public AspMvcActionAttribute(string anonymousProperty)
public AspMvcActionAttribute([NotNull] string anonymousProperty)
{
AnonymousProperty = anonymousProperty;
}
public string AnonymousProperty { get; private set; }
[CanBeNull] public string AnonymousProperty { get; private set; }
}
/// <summary>
@@ -596,12 +675,13 @@ namespace Filtration.ObjectModel.Annotations
public sealed class AspMvcAreaAttribute : Attribute
{
public AspMvcAreaAttribute() { }
public AspMvcAreaAttribute(string anonymousProperty)
public AspMvcAreaAttribute([NotNull] string anonymousProperty)
{
AnonymousProperty = anonymousProperty;
}
public string AnonymousProperty { get; private set; }
[CanBeNull] public string AnonymousProperty { get; private set; }
}
/// <summary>
@@ -614,12 +694,13 @@ namespace Filtration.ObjectModel.Annotations
public sealed class AspMvcControllerAttribute : Attribute
{
public AspMvcControllerAttribute() { }
public AspMvcControllerAttribute(string anonymousProperty)
public AspMvcControllerAttribute([NotNull] string anonymousProperty)
{
AnonymousProperty = anonymousProperty;
}
public string AnonymousProperty { get; private set; }
[CanBeNull] public string AnonymousProperty { get; private set; }
}
/// <summary>
@@ -649,7 +730,7 @@ namespace Filtration.ObjectModel.Annotations
/// 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 { }
public sealed class AspMvcSuppressViewErrorAttribute : Attribute { }
/// <summary>
/// ASP.NET MVC attribute. Indicates that a parameter is an MVC display template.
@@ -677,13 +758,27 @@ namespace Filtration.ObjectModel.Annotations
/// <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
/// is an MVC view component. If applied to a method, the MVC view name is calculated implicitly
/// from the context. Use this attribute for custom wrappers similar to
/// <c>System.Web.Mvc.Controller.View(Object)</c>.
/// </summary>
[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)]
public sealed class AspMvcViewAttribute : Attribute { }
/// <summary>
/// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
/// is an MVC view component name.
/// </summary>
[AttributeUsage(AttributeTargets.Parameter)]
public sealed class AspMvcViewComponentAttribute : Attribute { }
/// <summary>
/// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
/// is an MVC view component view. If applied to a method, the MVC view component view name is default.
/// </summary>
[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)]
public sealed class AspMvcViewComponentViewAttribute : Attribute { }
/// <summary>
/// ASP.NET MVC attribute. When applied to a parameter of an attribute,
/// indicates that this parameter is an MVC action name.
@@ -702,12 +797,13 @@ namespace Filtration.ObjectModel.Annotations
public sealed class HtmlElementAttributesAttribute : Attribute
{
public HtmlElementAttributesAttribute() { }
public HtmlElementAttributesAttribute(string name)
public HtmlElementAttributesAttribute([NotNull] string name)
{
Name = name;
}
public string Name { get; private set; }
[CanBeNull] public string Name { get; private set; }
}
[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
@@ -730,9 +826,10 @@ namespace Filtration.ObjectModel.Annotations
public sealed class RazorSectionAttribute : Attribute { }
/// <summary>
/// Indicates how method invocation affects content of the collection.
/// Indicates how method, constructor invocation or property access
/// over collection type affects content of the collection.
/// </summary>
[AttributeUsage(AttributeTargets.Method)]
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Property)]
public sealed class CollectionAccessAttribute : Attribute
{
public CollectionAccessAttribute(CollectionAccessType collectionAccessType)
@@ -824,6 +921,16 @@ namespace Filtration.ObjectModel.Annotations
[AttributeUsage(AttributeTargets.Parameter)]
public sealed class RegexPatternAttribute : 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.Class | AttributeTargets.Interface | AttributeTargets.Struct | AttributeTargets.Enum)]
public sealed class NoReorderAttribute : Attribute { }
/// <summary>
/// XAML attribute. Indicates the type that has <c>ItemsSource</c> property and should be treated
/// as <c>ItemsControl</c>-derived type, to enable inner items <c>DataContext</c> type resolve.
@@ -832,7 +939,7 @@ namespace Filtration.ObjectModel.Annotations
public sealed class XamlItemsControlAttribute : Attribute { }
/// <summary>
/// XAML attibute. Indicates the property of some <c>BindingBase</c>-derived type, that
/// XAML attribute. Indicates the property of some <c>BindingBase</c>-derived type, that
/// is used to bind some item of <c>ItemsControl</c>-derived type. This annotation will
/// enable the <c>DataContext</c> type resolve for XAML bindings for such properties.
/// </summary>
@@ -846,14 +953,15 @@ namespace Filtration.ObjectModel.Annotations
[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
public sealed class AspChildControlTypeAttribute : Attribute
{
public AspChildControlTypeAttribute(string tagName, Type controlType)
public AspChildControlTypeAttribute([NotNull] string tagName, [NotNull] Type controlType)
{
TagName = tagName;
ControlType = controlType;
}
public string TagName { get; private set; }
public Type ControlType { get; private set; }
[NotNull] public string TagName { get; private set; }
[NotNull] public Type ControlType { get; private set; }
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Method)]
@@ -873,7 +981,7 @@ namespace Filtration.ObjectModel.Annotations
Attribute = attribute;
}
public string Attribute { get; private set; }
[NotNull] public string Attribute { get; private set; }
}
[AttributeUsage(AttributeTargets.Property)]
@@ -890,25 +998,37 @@ namespace Filtration.ObjectModel.Annotations
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
public sealed class RazorImportNamespaceAttribute : Attribute
{
public RazorImportNamespaceAttribute(string name)
public RazorImportNamespaceAttribute([NotNull] string name)
{
Name = name;
}
public string Name { get; private set; }
[NotNull] public string Name { get; private set; }
}
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
public sealed class RazorInjectionAttribute : Attribute
{
public RazorInjectionAttribute(string type, string fieldName)
public RazorInjectionAttribute([NotNull] string type, [NotNull] string fieldName)
{
Type = type;
FieldName = fieldName;
}
public string Type { get; private set; }
public string FieldName { get; private set; }
[NotNull] public string Type { get; private set; }
[NotNull] public string FieldName { get; private set; }
}
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
public sealed class RazorDirectiveAttribute : Attribute
{
public RazorDirectiveAttribute([NotNull] string directive)
{
Directive = directive;
}
[NotNull] public string Directive { get; private set; }
}
[AttributeUsage(AttributeTargets.Method)]
@@ -925,13 +1045,4 @@ namespace Filtration.ObjectModel.Annotations
[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 { }
}

7
Filtration.ObjectModel/Properties/AssemblyInfo.cs
View File

@@ -1,4 +1,5 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
@@ -33,3 +34,9 @@ using System.Runtime.InteropServices;
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: InternalsVisibleTo("Filtration.ItemFilterPreview.Tests")]
[assembly: InternalsVisibleTo("Filtration.ObjectModel.Tests")]
[assembly: InternalsVisibleTo("Filtration.Parser.Tests")]
[assembly: InternalsVisibleTo("Filtration.Tests")]
[assembly: InternalsVisibleTo("Filtration.ThemeEditor.Tests")]

21
Filtration.ObjectModel/WindsorInstallers/CommandsInstaller.cs Normal file
View File

@@ -0,0 +1,21 @@
using Castle.MicroKernel.Registration;
using Castle.MicroKernel.SubSystems.Configuration;
using Castle.Windsor;
using Filtration.ObjectModel.Commands;
namespace Filtration.ObjectModel.WindsorInstallers
{
public class CommandsInstaller : IWindsorInstaller
{
public void Install(IWindsorContainer container, IConfigurationStore store)
{
container.Register(Component
.For<ICommandManager>()
.Forward<ICommandManagerInternal>()
.ImplementedBy<CommandManager>()
.LifestyleTransient());
}
}
}

23
Filtration.ObjectModel/WindsorInstallers/ModelsInstaller.cs Normal file
View File

@@ -0,0 +1,23 @@
using Castle.Facilities.TypedFactory;
using Castle.MicroKernel.Registration;
using Castle.MicroKernel.SubSystems.Configuration;
using Castle.Windsor;
using Filtration.ObjectModel.Factories;
namespace Filtration.ObjectModel.WindsorInstallers
{
public class ModelsInstaller : IWindsorInstaller
{
public void Install(IWindsorContainer container, IConfigurationStore store)
{
container.Register(Component
.For<IItemFilterScript>()
.ImplementedBy<ItemFilterScript>()
.LifestyleTransient());
container.Register(Component
.For<IItemFilterScriptFactory>()
.AsFactory());
}
}
}

5
Filtration.ObjectModel/packages.config Normal file
View File

@@ -0,0 +1,5 @@
<?xml version="1.0" encoding="utf-8"?>
<packages>
<package id="Castle.Core" version="3.3.0" targetFramework="net461" />
<package id="Castle.Windsor" version="3.4.0" targetFramework="net461" />
</packages>