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

Moved Object Model to separate project

Browse Source
This commit is contained in:
Ben
2015-06-24 19:57:16 +01:00
parent 1be6fe9e7b
commit c6f5dcda39
75 changed files with 1271 additions and 294 deletions
Download Patch File Download Diff File Expand all files Collapse all files

83
Filtration.ObjectModel/BlockItemBaseTypes/ActionBlockItem.cs Normal file
View File

@@ -0,0 +1,83 @@
using System.Windows.Media;
using Filtration.ObjectModel.Enums;
using Filtration.ObjectModel.Extensions;
namespace Filtration.ObjectModel.BlockItemBaseTypes
{
public class ActionBlockItem : BlockItemBase
{
private BlockAction _action;
public ActionBlockItem(BlockAction action)
{
Action = action;
}
public BlockAction Action
{
get { return _action; }
set
{
_action = value;
OnPropertyChanged();
OnPropertyChanged("SummaryText");
OnPropertyChanged("SummaryBackgroundColor");
OnPropertyChanged("SummaryTextColor");
}
}
public override string OutputText
{
get { return Action.GetAttributeDescription(); }
}
public override string PrefixText
{
get { return string.Empty; }
}
public override int MaximumAllowed
{
get { return 1; }
}
public override string DisplayHeading
{
get
{
return "Action";
}
}
public override string SummaryText
{
get
{
return Action == BlockAction.Show ? "Show" : "Hide";
}
}
public override Color SummaryBackgroundColor
{
get
{
return Action == BlockAction.Show ? Colors.LimeGreen : Colors.OrangeRed;
}
}
public override Color SummaryTextColor
{
get
{
return Action == BlockAction.Show ? Colors.Black : Colors.White;
}
}
public override int SortOrder { get { return 0; } }
public void ToggleAction()
{
Action = Action == BlockAction.Show ? BlockAction.Hide : BlockAction.Show;
}
}
}

28
Filtration.ObjectModel/BlockItemBaseTypes/BlockItembase.cs Normal file
View File

@@ -0,0 +1,28 @@
using System.ComponentModel;
using System.Runtime.CompilerServices;
using System.Windows.Media;
using Filtration.ObjectModel.Annotations;
namespace Filtration.ObjectModel.BlockItemBaseTypes
{
public abstract class BlockItemBase : IItemFilterBlockItem
{
public abstract string PrefixText { get; }
public abstract string OutputText { get; }
public abstract int MaximumAllowed { get; }
public abstract string DisplayHeading { get; }
public abstract string SummaryText { get; }
public abstract Color SummaryBackgroundColor { get; }
public abstract Color SummaryTextColor { get; }
public abstract int SortOrder { get; }
public event PropertyChangedEventHandler PropertyChanged;
[NotifyPropertyChangedInvocator]
protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
{
var handler = PropertyChanged;
if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
}
}
}

45
Filtration.ObjectModel/BlockItemBaseTypes/ColorBlockItem.cs Normal file
View File

@@ -0,0 +1,45 @@
using System.Windows.Media;
namespace Filtration.ObjectModel.BlockItemBaseTypes
{
public abstract class ColorBlockItem : BlockItemBase, IAudioVisualBlockItem
{
private Color _color;
protected ColorBlockItem()
{
}
protected ColorBlockItem(Color color)
{
Color = color;
}
public override string OutputText
{
get
{
return PrefixText + " " + +Color.R + " " + Color.G + " "
+ Color.B + (Color.A < 255 ? " " + Color.A : string.Empty);
}
}
public override string SummaryText
{
get { return string.Empty; }
}
public override Color SummaryBackgroundColor { get { return Colors.Transparent; } }
public override Color SummaryTextColor { get { return Colors.Transparent; } }
public Color Color
{
get { return _color; }
set
{
_color = value;
OnPropertyChanged();
}
}
}
}

49
Filtration.ObjectModel/BlockItemBaseTypes/DualIntegerBlockItem.cs Normal file
View File

@@ -0,0 +1,49 @@
using System.Windows.Media;
namespace Filtration.ObjectModel.BlockItemBaseTypes
{
public abstract class DualIntegerBlockItem : BlockItemBase, IAudioVisualBlockItem
{
private int _value;
private int _secondValue;
protected DualIntegerBlockItem()
{
}
protected DualIntegerBlockItem(int value, int secondValue)
{
Value = value;
SecondValue = secondValue;
}
public override string OutputText
{
get { return PrefixText + " " + Value + " " + SecondValue; }
}
public override string SummaryText { get { return string.Empty; } }
public override Color SummaryBackgroundColor { get { return Colors.Transparent; } }
public override Color SummaryTextColor { get { return Colors.Transparent; } }
public int Value
{
get { return _value; }
set
{
_value = value;
OnPropertyChanged();
}
}
public int SecondValue
{
get { return _secondValue; }
set
{
_secondValue = value;
OnPropertyChanged();
}
}
}
}

40
Filtration.ObjectModel/BlockItemBaseTypes/IntegerBlockItem.cs Normal file
View File

@@ -0,0 +1,40 @@
using System.Windows.Media;
namespace Filtration.ObjectModel.BlockItemBaseTypes
{
public abstract class IntegerBlockItem : BlockItemBase, IAudioVisualBlockItem
{
private int _value;
protected IntegerBlockItem()
{
}
protected IntegerBlockItem(int value)
{
Value = value;
}
public override string OutputText
{
get { return PrefixText + " " + Value; }
}
public override string SummaryText { get { return string.Empty; } }
public override Color SummaryBackgroundColor { get { return Colors.Transparent; } }
public override Color SummaryTextColor { get { return Colors.Transparent; } }
public abstract int Minimum { get; }
public abstract int Maximum { get; }
public int Value
{
get { return _value; }
set
{
_value = value;
OnPropertyChanged();
}
}
}
}

51
Filtration.ObjectModel/BlockItemBaseTypes/NumericFilterPredicateBlockItem.cs Normal file
View File

@@ -0,0 +1,51 @@
using System;
using Filtration.ObjectModel.Enums;
using Filtration.ObjectModel.Extensions;
namespace Filtration.ObjectModel.BlockItemBaseTypes
{
public abstract class NumericFilterPredicateBlockItem : BlockItemBase
{
private NumericFilterPredicate _filterPredicate;
protected NumericFilterPredicateBlockItem()
{
FilterPredicate = new NumericFilterPredicate();
FilterPredicate.PropertyChanged += OnFilterPredicateChanged;
}
protected NumericFilterPredicateBlockItem(FilterPredicateOperator predicateOperator, int predicateOperand)
{
FilterPredicate = new NumericFilterPredicate(predicateOperator, predicateOperand);
FilterPredicate.PropertyChanged += OnFilterPredicateChanged;
}
public override string OutputText
{
get
{
return PrefixText + " " + FilterPredicate.PredicateOperator.GetAttributeDescription() +
" " + FilterPredicate.PredicateOperand;
}
}
public abstract int Minimum { get; }
public abstract int Maximum { get; }
public NumericFilterPredicate FilterPredicate
{
get { return _filterPredicate; }
protected set
{
_filterPredicate = value;
OnPropertyChanged();
}
}
private void OnFilterPredicateChanged(object sender, EventArgs e)
{
OnPropertyChanged("FilterPredicate");
OnPropertyChanged("SummaryText");
}
}
}

40
Filtration.ObjectModel/BlockItemBaseTypes/StringListBlockItem.cs Normal file
View File

@@ -0,0 +1,40 @@
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Linq;
namespace Filtration.ObjectModel.BlockItemBaseTypes
{
public abstract class StringListBlockItem : BlockItemBase
{
protected StringListBlockItem()
{
Items = new ObservableCollection<string>();
Items.CollectionChanged += OnItemsCollectionChanged;
}
public override string OutputText
{
get
{
var enumerable = Items as IList<string> ?? Items.ToList();
if (enumerable.Count > 0)
{
return PrefixText + " " +
string.Format("\"{0}\"",
string.Join("\" \"", enumerable.ToArray()));
}
return string.Empty;
}
}
public ObservableCollection<string> Items { get; protected set; }
private void OnItemsCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
OnPropertyChanged("Items");
OnPropertyChanged("SummaryText");
}
}
}

39
Filtration.ObjectModel/BlockItemTypes/BackgroundColorBlockItem.cs Normal file
View File

@@ -0,0 +1,39 @@
using System.Windows.Media;
using Filtration.ObjectModel.BlockItemBaseTypes;
namespace Filtration.ObjectModel.BlockItemTypes
{
public class BackgroundColorBlockItem : ColorBlockItem
{
public BackgroundColorBlockItem()
{
}
public BackgroundColorBlockItem(Color color) : base(color)
{
}
public override string PrefixText
{
get { return "SetBackgroundColor"; }
}
public override int MaximumAllowed
{
get { return 1; }
}
public override string DisplayHeading
{
get
{
return "Background Color";
}
}
public override int SortOrder
{
get { return 13; }
}
}
}

60
Filtration.ObjectModel/BlockItemTypes/BaseTypeBlockItem.cs Normal file
View File

@@ -0,0 +1,60 @@
using System.Linq;
using System.Windows.Media;
using Filtration.ObjectModel.BlockItemBaseTypes;
namespace Filtration.ObjectModel.BlockItemTypes
{
public class BaseTypeBlockItem : StringListBlockItem
{
public override string PrefixText { get { return "BaseType"; } }
public override int MaximumAllowed
{
get { return 1; }
}
public override string DisplayHeading
{
get
{
return "Base Type";
}
}
public override string SummaryText
{
get
{
if (Items.Count > 0 && Items.Count < 4)
{
return "Item Base Types: " +
Items.Aggregate(string.Empty, (current, i) => current + i + ", ").TrimEnd(' ').TrimEnd(',');
}
if (Items.Count >= 4)
{
var remaining = Items.Count - 3;
return "Item Base Types: " + Items.Take(3)
.Aggregate(string.Empty, (current, i) => current + i + ", ")
.TrimEnd(' ')
.TrimEnd(',') + " (+" + remaining + " more)";
}
return "Item Base Types: (none)";
}
}
public override Color SummaryBackgroundColor
{
get { return Colors.MediumTurquoise; }
}
public override Color SummaryTextColor
{
get { return Colors.Black; }
}
public override int SortOrder
{
get { return 11; }
}
}
}

39
Filtration.ObjectModel/BlockItemTypes/BorderColorBlockItem.cs Normal file
View File

@@ -0,0 +1,39 @@
using System.Windows.Media;
using Filtration.ObjectModel.BlockItemBaseTypes;
namespace Filtration.ObjectModel.BlockItemTypes
{
public class BorderColorBlockItem : ColorBlockItem
{
public BorderColorBlockItem()
{
}
public BorderColorBlockItem(Color color) : base(color)
{
}
public override string PrefixText
{
get { return "SetBorderColor"; }
}
public override int MaximumAllowed
{
get { return 1; }
}
public override string DisplayHeading
{
get
{
return "Border Color";
}
}
public override int SortOrder
{
get { return 14; }
}
}
}

54
Filtration.ObjectModel/BlockItemTypes/ClassBlockItem.cs Normal file
View File

@@ -0,0 +1,54 @@
using System.Linq;
using System.Windows.Media;
using Filtration.ObjectModel.BlockItemBaseTypes;
namespace Filtration.ObjectModel.BlockItemTypes
{
public class ClassBlockItem : StringListBlockItem
{
public override string PrefixText { get { return "Class"; } }
public override int MaximumAllowed
{
get { return 1; }
}
public override string DisplayHeading { get { return "Class"; } }
public override string SummaryText
{
get
{
if (Items.Count > 0 && Items.Count < 4)
{
return "Item Classes: " +
Items.Aggregate(string.Empty, (current, i) => current + i + ", ").TrimEnd(' ').TrimEnd(',');
}
if (Items.Count >= 4)
{
var remaining = Items.Count - 3;
return "Item Classes: " + Items.Take(3)
.Aggregate(string.Empty, (current, i) => current + i + ", ")
.TrimEnd(' ')
.TrimEnd(',') + " (+" + remaining + " more)";
}
return "Item Classes: (none)";
}
}
public override Color SummaryBackgroundColor
{
get { return Colors.MediumSeaGreen; }
}
public override Color SummaryTextColor
{
get { return Colors.White; }
}
public override int SortOrder
{
get { return 10; }
}
}
}

72
Filtration.ObjectModel/BlockItemTypes/DropLevelBlockItem.cs Normal file
View File

@@ -0,0 +1,72 @@
using System.Windows.Media;
using Filtration.ObjectModel.BlockItemBaseTypes;
using Filtration.ObjectModel.Enums;
namespace Filtration.ObjectModel.BlockItemTypes
{
public class DropLevelBlockItem : NumericFilterPredicateBlockItem
{
public DropLevelBlockItem()
{
}
public DropLevelBlockItem(FilterPredicateOperator predicateOperator, int predicateOperand)
: base(predicateOperator, predicateOperand)
{
}
public override string PrefixText
{
get { return "DropLevel"; }
}
public override int MaximumAllowed
{
get { return 2; }
}
public override string DisplayHeading
{
get
{
return "Drop Level";
}
}
public override string SummaryText
{
get { return "Drop Level " + FilterPredicate; }
}
public override Color SummaryBackgroundColor
{
get { return Colors.DodgerBlue; }
}
public override Color SummaryTextColor
{
get { return Colors.White; }
}
public override int SortOrder
{
get { return 2; }
}
public override int Minimum
{
get
{
return 0;
}
}
public override int Maximum
{
get
{
return 100;
}
}
}
}

55
Filtration.ObjectModel/BlockItemTypes/FontSizeBlockItem.cs Normal file
View File

@@ -0,0 +1,55 @@
using Filtration.ObjectModel.BlockItemBaseTypes;
namespace Filtration.ObjectModel.BlockItemTypes
{
public class FontSizeBlockItem : IntegerBlockItem
{
public FontSizeBlockItem()
{
Value = 35;
}
public FontSizeBlockItem(int value) : base(value)
{
}
public override string PrefixText
{
get { return "SetFontSize"; }
}
public override int MaximumAllowed
{
get { return 1; }
}
public override string DisplayHeading
{
get
{
return "Font Size";
}
}
public override int SortOrder
{
get { return 15; }
}
public override int Minimum
{
get
{
return 11;
}
}
public override int Maximum
{
get
{
return 45;
}
}
}
}

69
Filtration.ObjectModel/BlockItemTypes/HeightBlockItem.cs Normal file
View File

@@ -0,0 +1,69 @@
using System.Windows.Media;
using Filtration.ObjectModel.BlockItemBaseTypes;
using Filtration.ObjectModel.Enums;
namespace Filtration.ObjectModel.BlockItemTypes
{
public class HeightBlockItem : NumericFilterPredicateBlockItem
{
public HeightBlockItem()
{
}
public HeightBlockItem(FilterPredicateOperator predicateOperator, int predicateOperand)
: base(predicateOperator, predicateOperand)
{
}
public override string PrefixText
{
get { return "Height"; }
}
public override int MaximumAllowed
{
get { return 2; }
}
public override string DisplayHeading
{
get { return "Height"; }
}
public override string SummaryText
{
get { return "Height " + FilterPredicate; }
}
public override Color SummaryBackgroundColor
{
get { return Colors.LightBlue; }
}
public override Color SummaryTextColor
{
get { return Colors.Black; }
}
public override int SortOrder
{
get { return 8; }
}
public override int Minimum
{
get
{
return 0;
}
}
public override int Maximum
{
get
{
return 6;
}
}
}
}

71
Filtration.ObjectModel/BlockItemTypes/ItemLevelBlockItem.cs Normal file
View File

@@ -0,0 +1,71 @@
using System.Windows.Media;
using Filtration.ObjectModel.BlockItemBaseTypes;
using Filtration.ObjectModel.Enums;
namespace Filtration.ObjectModel.BlockItemTypes
{
public class ItemLevelBlockItem : NumericFilterPredicateBlockItem
{
public ItemLevelBlockItem()
{
}
public ItemLevelBlockItem(FilterPredicateOperator predicateOperator, int predicateOperand) : base (predicateOperator, predicateOperand)
{
}
public override string PrefixText
{
get { return "ItemLevel"; }
}
public override int MaximumAllowed
{
get { return 2; }
}
public override string DisplayHeading
{
get
{
return "Item Level";
}
}
public override string SummaryText
{
get { return "Item Level " + FilterPredicate; }
}
public override Color SummaryBackgroundColor
{
get { return Colors.DarkSlateGray; }
}
public override Color SummaryTextColor
{
get { return Colors.White; }
}
public override int SortOrder
{
get { return 1; }
}
public override int Minimum
{
get
{
return 0;
}
}
public override int Maximum
{
get
{
return 100;
}
}
}
}

72
Filtration.ObjectModel/BlockItemTypes/LinkedSocketsBlockItem.cs Normal file
View File

@@ -0,0 +1,72 @@
using System.Windows.Media;
using Filtration.ObjectModel.BlockItemBaseTypes;
using Filtration.ObjectModel.Enums;
namespace Filtration.ObjectModel.BlockItemTypes
{
public class LinkedSocketsBlockItem : NumericFilterPredicateBlockItem
{
public LinkedSocketsBlockItem()
{
}
public LinkedSocketsBlockItem(FilterPredicateOperator predicateOperator, int predicateOperand)
: base(predicateOperator, predicateOperand)
{
}
public override string PrefixText
{
get { return "LinkedSockets"; }
}
public override int MaximumAllowed
{
get { return 2; }
}
public override string DisplayHeading
{
get
{
return "Linked Sockets";
}
}
public override string SummaryText
{
get { return "Linked Sockets " + FilterPredicate; }
}
public override Color SummaryBackgroundColor
{
get { return Colors.Gold; }
}
public override Color SummaryTextColor
{
get { return Colors.Black; }
}
public override int SortOrder
{
get { return 6; }
}
public override int Minimum
{
get
{
return 0;
}
}
public override int Maximum
{
get
{
return 6;
}
}
}
}

72
Filtration.ObjectModel/BlockItemTypes/QualityBlockItem.cs Normal file
View File

@@ -0,0 +1,72 @@
using System.Windows.Media;
using Filtration.ObjectModel.BlockItemBaseTypes;
using Filtration.ObjectModel.Enums;
namespace Filtration.ObjectModel.BlockItemTypes
{
public class QualityBlockItem : NumericFilterPredicateBlockItem
{
public QualityBlockItem()
{
}
public QualityBlockItem(FilterPredicateOperator predicateOperator, int predicateOperand)
: base(predicateOperator, predicateOperand)
{
}
public override string PrefixText
{
get { return "Quality"; }
}
public override int MaximumAllowed
{
get { return 2; }
}
public override string DisplayHeading
{
get
{
return "Quality";
}
}
public override string SummaryText
{
get { return "Quality " + FilterPredicate; }
}
public override Color SummaryBackgroundColor
{
get { return Colors.DarkOrange; }
}
public override Color SummaryTextColor
{
get { return Colors.White; }
}
public override int SortOrder
{
get { return 3; }
}
public override int Minimum
{
get
{
return 0;
}
}
public override int Maximum
{
get
{
return 20;
}
}
}
}

89
Filtration.ObjectModel/BlockItemTypes/RarityBlockItem.cs Normal file
View File

@@ -0,0 +1,89 @@
using System.Windows.Media;
using Filtration.ObjectModel.BlockItemBaseTypes;
using Filtration.ObjectModel.Enums;
using Filtration.ObjectModel.Extensions;
namespace Filtration.ObjectModel.BlockItemTypes
{
public class RarityBlockItem : NumericFilterPredicateBlockItem
{
public RarityBlockItem()
{
}
public RarityBlockItem(FilterPredicateOperator predicateOperator, int predicateOperand)
: base(predicateOperator, predicateOperand)
{
}
public override string PrefixText
{
get { return "Rarity"; }
}
public override string OutputText
{
get
{
return PrefixText + " " + FilterPredicate.PredicateOperator
.GetAttributeDescription() +
" " +
((ItemRarity) FilterPredicate.PredicateOperand)
.GetAttributeDescription();
}
}
public override int MaximumAllowed
{
get { return 2; }
}
public override string DisplayHeading
{
get
{
return "Item Rarity";
}
}
public override string SummaryText
{
get
{
return "Rarity " + FilterPredicate.PredicateOperator.GetAttributeDescription() + " " +
((ItemRarity) FilterPredicate.PredicateOperand).GetAttributeDescription();
}
}
public override Color SummaryBackgroundColor
{
get { return Colors.LightCoral; }
}
public override Color SummaryTextColor
{
get { return Colors.White; }
}
public override int SortOrder
{
get { return 4; }
}
public override int Minimum
{
get
{
return 0;
}
}
public override int Maximum
{
get
{
return (int)ItemRarity.Unique;
}
}
}
}

51
Filtration.ObjectModel/BlockItemTypes/SocketGroupBlockItem.cs Normal file
View File

@@ -0,0 +1,51 @@
using System.Linq;
using System.Windows.Media;
using Filtration.ObjectModel.BlockItemBaseTypes;
namespace Filtration.ObjectModel.BlockItemTypes
{
public class SocketGroupBlockItem : StringListBlockItem
{
public override string PrefixText
{
get { return "SocketGroup"; }
}
public override int MaximumAllowed
{
get { return 1; }
}
public override string DisplayHeading
{
get
{
return "Socket Group";
}
}
public override string SummaryText
{
get
{
var summaryItemText = " " + Items.Aggregate(string.Empty, (current, i) => current + " " + i);
return "Socket Group " + summaryItemText.TrimStart(' ');
}
}
public override Color SummaryBackgroundColor
{
get { return Colors.GhostWhite; }
}
public override Color SummaryTextColor
{
get { return Colors.Black; }
}
public override int SortOrder
{
get { return 9; }
}
}
}

72
Filtration.ObjectModel/BlockItemTypes/SocketsBlockItem.cs Normal file
View File

@@ -0,0 +1,72 @@
using System.Windows.Media;
using Filtration.ObjectModel.BlockItemBaseTypes;
using Filtration.ObjectModel.Enums;
namespace Filtration.ObjectModel.BlockItemTypes
{
public class SocketsBlockItem : NumericFilterPredicateBlockItem
{
public SocketsBlockItem()
{
}
public SocketsBlockItem(FilterPredicateOperator predicateOperator, int predicateOperand)
: base(predicateOperator, predicateOperand)
{
}
public override string PrefixText
{
get { return "Sockets"; }
}
public override int MaximumAllowed
{
get { return 2; }
}
public override string DisplayHeading
{
get
{
return "Sockets";
}
}
public override string SummaryText
{
get { return "Sockets " + FilterPredicate; }
}
public override Color SummaryBackgroundColor
{
get { return Colors.LightGray; }
}
public override Color SummaryTextColor
{
get { return Colors.Black; }
}
public override int SortOrder
{
get { return 5; }
}
public override int Minimum
{
get
{
return 0;
}
}
public override int Maximum
{
get
{
return 6;
}
}
}
}

40
Filtration.ObjectModel/BlockItemTypes/SoundBlockItem.cs Normal file
View File

@@ -0,0 +1,40 @@
using Filtration.ObjectModel.BlockItemBaseTypes;
namespace Filtration.ObjectModel.BlockItemTypes
{
public class SoundBlockItem : DualIntegerBlockItem
{
public SoundBlockItem()
{
Value = 1;
SecondValue = 79;
}
public SoundBlockItem(int value, int secondValue) : base(value, secondValue)
{
}
public override string PrefixText
{
get { return "PlayAlertSound"; }
}
public override int MaximumAllowed
{
get { return 1; }
}
public override string DisplayHeading
{
get
{
return "Play Alert Sound";
}
}
public override int SortOrder
{
get { return 16; }
}
}
}

39
Filtration.ObjectModel/BlockItemTypes/TextColorBlockItem.cs Normal file
View File

@@ -0,0 +1,39 @@
using System.Windows.Media;
using Filtration.ObjectModel.BlockItemBaseTypes;
namespace Filtration.ObjectModel.BlockItemTypes
{
public class TextColorBlockItem : ColorBlockItem
{
public TextColorBlockItem()
{
}
public TextColorBlockItem(Color color) : base(color)
{
}
public override string PrefixText
{
get { return "SetTextColor"; }
}
public override int MaximumAllowed
{
get { return 1; }
}
public override string DisplayHeading
{
get
{
return "Text Color";
}
}
public override int SortOrder
{
get { return 12; }
}
}
}

72
Filtration.ObjectModel/BlockItemTypes/WidthBlockItem.cs Normal file
View File

@@ -0,0 +1,72 @@
using System.Windows.Media;
using Filtration.ObjectModel.BlockItemBaseTypes;
using Filtration.ObjectModel.Enums;
namespace Filtration.ObjectModel.BlockItemTypes
{
public class WidthBlockItem : NumericFilterPredicateBlockItem
{
public WidthBlockItem()
{
}
public WidthBlockItem(FilterPredicateOperator predicateOperator, int predicateOperand)
: base(predicateOperator, predicateOperand)
{
}
public override string PrefixText
{
get { return "Width"; }
}
public override int MaximumAllowed
{
get { return 2; }
}
public override string DisplayHeading
{
get
{
return "Width";
}
}
public override string SummaryText
{
get { return "Width " + FilterPredicate; }
}
public override Color SummaryBackgroundColor
{
get { return Colors.MediumPurple; }
}
public override Color SummaryTextColor
{
get { return Colors.White; }
}
public override int SortOrder
{
get { return 7; }
}
public override int Minimum
{
get
{
return 0;
}
}
public override int Maximum
{
get
{
return 2;
}
}
}
}

12
Filtration.ObjectModel/Enums/BlockAction.cs Normal file
View File

@@ -0,0 +1,12 @@
using System.ComponentModel;
namespace Filtration.ObjectModel.Enums
{
public enum BlockAction
{
[Description("Show")]
Show,
[Description("Hide")]
Hide
}
}

22
Filtration.ObjectModel/Enums/BlockItemType.cs Normal file
View File

@@ -0,0 +1,22 @@
namespace Filtration.ObjectModel.Enums
{
public enum BlockItemType
{
ItemLevel,
DropLevel,
Quality,
Rarity,
Class,
BaseType,
Sockets,
LinkedSockets,
SocketGroup,
Width,
Height,
TextColor,
BackgroundColor,
BorderColor,
Sound,
FontSize
}
}

20
Filtration.ObjectModel/Enums/FilterPredicateOperator.cs Normal file
View File

@@ -0,0 +1,20 @@
using System.ComponentModel;
namespace Filtration.ObjectModel.Enums
{
public enum FilterPredicateOperator
{
[Description("=")]
Equal,
[Description("!=")]
NotEqual,
[Description("<")]
LessThan,
[Description("<=")]
LessThanOrEqual,
[Description(">")]
GreaterThan,
[Description(">=")]
GreaterThanOrEqual
}
}

12
Filtration.ObjectModel/Enums/FilterType.cs Normal file
View File

@@ -0,0 +1,12 @@
using System.ComponentModel;
namespace Filtration.ObjectModel.Enums
{
public enum FilterType
{
[Description("Show")]
Show,
[Description("Hide")]
Hide
}
}

16
Filtration.ObjectModel/Enums/ItemRarity.cs Normal file
View File

@@ -0,0 +1,16 @@
using System.ComponentModel;
namespace Filtration.ObjectModel.Enums
{
public enum ItemRarity
{
[Description("Normal")]
Normal,
[Description("Magic")]
Magic,
[Description("Rare")]
Rare,
[Description("Unique")]
Unique
}
}

16
Filtration.ObjectModel/Enums/SocketColor.cs Normal file
View File

@@ -0,0 +1,16 @@
using System.ComponentModel;
namespace Filtration.ObjectModel.Enums
{
public enum SocketColor
{
[Description("R")]
Red,
[Description("G")]
Green,
[Description("B")]
Blue,
[Description("W")]
White
}
}

38
Filtration.ObjectModel/Extensions/EnumHelper.cs Normal file
View File

@@ -0,0 +1,38 @@
using System;
using System.ComponentModel;
namespace Filtration.ObjectModel.Extensions
{
public static class EnumHelper
{
public static T GetAttributeOfType<T>(this Enum enumVal) where T : Attribute
{
var type = enumVal.GetType();
var memInfo = type.GetMember(enumVal.ToString());
var attributes = memInfo[0].GetCustomAttributes(typeof(T), false);
return (attributes.Length > 0) ? (T)attributes[0] : null;
}
public static string GetAttributeDescription(this Enum enumValue)
{
var attribute = enumValue.GetAttributeOfType<DescriptionAttribute>();
return attribute == null ? String.Empty : attribute.Description;
}
public static T GetEnumValueFromDescription<T>(string description)
{
var fis = typeof(T).GetFields();
foreach (var fi in fis)
{
DescriptionAttribute[] attributes = (DescriptionAttribute[])fi.GetCustomAttributes(typeof(DescriptionAttribute), false);
if (attributes.Length > 0 && attributes[0].Description == description)
return (T)Enum.Parse(typeof(T), fi.Name);
}
throw new Exception("Not found");
}
}
}

92
Filtration.ObjectModel/Filtration.ObjectModel.csproj Normal file
View File

@@ -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>

9
Filtration.ObjectModel/IAudioVisualBlockItem.cs Normal file
View File

@@ -0,0 +1,9 @@
using System.ComponentModel;
namespace Filtration.ObjectModel
{
public interface IAudioVisualBlockItem
{
event PropertyChangedEventHandler PropertyChanged;
}
}

17
Filtration.ObjectModel/IItemFilterBlockItem.cs Normal file
View File

@@ -0,0 +1,17 @@
using System.ComponentModel;
using System.Windows.Media;
namespace Filtration.ObjectModel
{
public interface IItemFilterBlockItem : INotifyPropertyChanged
{
string PrefixText { get; }
string OutputText { get; }
string DisplayHeading { get; }
string SummaryText { get; }
Color SummaryBackgroundColor { get; }
Color SummaryTextColor { get; }
int MaximumAllowed { get; }
int SortOrder { get; }
}
}

109
Filtration.ObjectModel/ItemFilterBlock.cs Normal file
View File

@@ -0,0 +1,109 @@
using System;
using System.Collections.ObjectModel;
using System.Linq;
using Filtration.ObjectModel.BlockItemBaseTypes;
using Filtration.ObjectModel.Enums;
namespace Filtration.ObjectModel
{
public class ItemFilterBlock
{
private ItemFilterBlockGroup _blockGroup;
public ItemFilterBlock()
{
BlockItems = new ObservableCollection<IItemFilterBlockItem> {new ActionBlockItem(BlockAction.Show)};
}
public string Description { get; set; }
public ItemFilterBlockGroup BlockGroup
{
get { return _blockGroup; }
set
{
var oldBlockGroup = _blockGroup;
_blockGroup = value;
if (_blockGroup != null)
{
_blockGroup.BlockGroupStatusChanged += OnBlockGroupStatusChanged;
if (oldBlockGroup != null)
{
oldBlockGroup.BlockGroupStatusChanged -= OnBlockGroupStatusChanged;
}
}
else
{
if (oldBlockGroup != null)
{
oldBlockGroup.BlockGroupStatusChanged -= OnBlockGroupStatusChanged;
}
}
}
}
public BlockAction Action
{
get
{
var actionBlock = BlockItems.OfType<ActionBlockItem>().First();
return actionBlock.Action;
}
set
{
var actionBlock = BlockItems.OfType<ActionBlockItem>().First();
actionBlock.Action = value;
}
}
public ObservableCollection<IItemFilterBlockItem> BlockItems { get; private set; }
public int BlockCount(Type type)
{
return BlockItems != null ? BlockItems.Count(b => b.GetType() == type) : 0;
}
public bool AddBlockItemAllowed(Type type)
{
var blockItem = (IItemFilterBlockItem)Activator.CreateInstance(type);
return BlockCount(type) < blockItem.MaximumAllowed;
}
public bool HasBlockItemOfType<T>()
{
return BlockItems.Count(b => b is T) > 0;
}
public bool HasBlockGroupInParentHierarchy(ItemFilterBlockGroup targetBlockGroup, ItemFilterBlockGroup startingBlockGroup)
{
if (startingBlockGroup == targetBlockGroup)
{
return true;
}
if (BlockGroup == null)
{
return false;
}
if (startingBlockGroup.ParentGroup != null)
{
return HasBlockGroupInParentHierarchy(targetBlockGroup, startingBlockGroup.ParentGroup);
}
return false;
}
private void OnBlockGroupStatusChanged(object sender, EventArgs e)
{
if (BlockGroup.IsChecked == false && Action == BlockAction.Show)
{
Action = BlockAction.Hide;
}
else if (BlockGroup.IsChecked && Action == BlockAction.Hide)
{
Action = BlockAction.Show;
}
}
}
}

62
Filtration.ObjectModel/ItemFilterBlockGroup.cs Normal file
View File

@@ -0,0 +1,62 @@
using System;
using System.Collections.Generic;
namespace Filtration.ObjectModel
{
public class ItemFilterBlockGroup
{
private bool _isChecked;
public ItemFilterBlockGroup(string groupName, ItemFilterBlockGroup parent, bool advanced = false)
{
GroupName = groupName;
ParentGroup = parent;
Advanced = advanced;
ChildGroups = new List<ItemFilterBlockGroup>();
}
public event EventHandler BlockGroupStatusChanged;
public string GroupName { get; private set; }
public ItemFilterBlockGroup ParentGroup { get; private set; }
public List<ItemFilterBlockGroup> ChildGroups { get; private set; }
public bool Advanced { get; private set; }
public bool IsChecked
{
get { return _isChecked; }
set
{
if (value != _isChecked)
{
_isChecked = value;
// Raise an event to let blocks that have this block group assigned that
// they might need to change their Action due to the block group status changing.
if (BlockGroupStatusChanged != null)
{
BlockGroupStatusChanged.Invoke(null, null);
}
}
}
}
public override string ToString()
{
var currentBlockGroup = this;
var outputString = GroupName;
// TODO: This is retarded, fix this.
if (currentBlockGroup.ParentGroup != null)
{
while (currentBlockGroup.ParentGroup.ParentGroup != null)
{
outputString = currentBlockGroup.ParentGroup.GroupName + " - " + outputString;
currentBlockGroup = currentBlockGroup.ParentGroup;
}
}
return outputString;
}
}
}

99
Filtration.ObjectModel/ItemFilterScript.cs Normal file
View File

@@ -0,0 +1,99 @@
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using Filtration.ObjectModel.BlockItemTypes;
namespace Filtration.ObjectModel
{
public class ItemFilterScript
{
public ItemFilterScript()
{
ItemFilterBlocks = new ObservableCollection<ItemFilterBlock>();
ItemFilterBlockGroups = new ObservableCollection<ItemFilterBlockGroup>
{
new ItemFilterBlockGroup("Root", null)
};
}
public ObservableCollection<ItemFilterBlock> ItemFilterBlocks { get; private set; }
public ObservableCollection<ItemFilterBlockGroup> ItemFilterBlockGroups { get; private set; }
public string FilePath { get; set; }
public string Description { get; set; }
public DateTime DateModified { get; set; }
public List<string> Validate()
{
var validationErrors = new List<string>();
if (ItemFilterBlocks.Count == 0)
{
validationErrors.Add("A script must have at least one block");
}
return validationErrors;
}
public void ReplaceColors(ReplaceColorsParameterSet replaceColorsParameterSet)
{
foreach (
var block in
ItemFilterBlocks.Where(b => BlockIsColorReplacementCandidate(replaceColorsParameterSet, b)))
{
if (replaceColorsParameterSet.ReplaceTextColor)
{
var textColorBlockItem = block.BlockItems.OfType<TextColorBlockItem>().First();
textColorBlockItem.Color = replaceColorsParameterSet.NewTextColor;
}
if (replaceColorsParameterSet.ReplaceBackgroundColor)
{
var backgroundColorBlockItem = block.BlockItems.OfType<BackgroundColorBlockItem>().First();
backgroundColorBlockItem.Color = replaceColorsParameterSet.NewBackgroundColor;
}
if (replaceColorsParameterSet.ReplaceBorderColor)
{
var borderColorBlockItem = block.BlockItems.OfType<BorderColorBlockItem>().First();
borderColorBlockItem.Color = replaceColorsParameterSet.NewBorderColor;
}
}
}
private bool BlockIsColorReplacementCandidate(ReplaceColorsParameterSet replaceColorsParameterSet, ItemFilterBlock 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;
// 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) ||
(backgroundColorItem == null && replaceColorsParameterSet.ReplaceBackgroundColor) ||
(borderColorItem == null && replaceColorsParameterSet.ReplaceBorderColor))
{
return false;
}
if ((replaceColorsParameterSet.ReplaceTextColor &&
textColorItem.Color != replaceColorsParameterSet.OldTextColor) ||
(replaceColorsParameterSet.ReplaceBackgroundColor &&
backgroundColorItem.Color != replaceColorsParameterSet.OldBackgroundColor) ||
(replaceColorsParameterSet.ReplaceBorderColor &&
borderColorItem.Color != replaceColorsParameterSet.OldBorderColor))
{
return false;
}
return true;
}
}
}

6
Filtration.ObjectModel/ItemFilterSection.cs Normal file
View File

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

59
Filtration.ObjectModel/NumericFilterPredicate.cs Normal file
View File

@@ -0,0 +1,59 @@
using System.ComponentModel;
using System.Runtime.CompilerServices;
using Filtration.ObjectModel.Annotations;
using Filtration.ObjectModel.Enums;
using Filtration.ObjectModel.Extensions;
namespace Filtration.ObjectModel
{
public class NumericFilterPredicate : INotifyPropertyChanged
{
private FilterPredicateOperator _predicateOperator;
private int _predicateOperand;
public NumericFilterPredicate(FilterPredicateOperator predicateOperator, int predicateOperand)
{
PredicateOperator = predicateOperator;
PredicateOperand = predicateOperand;
}
public NumericFilterPredicate()
{
}
public FilterPredicateOperator PredicateOperator
{
get { return _predicateOperator; }
set
{
_predicateOperator = value;
OnPropertyChanged();
}
}
public int PredicateOperand
{
get { return _predicateOperand; }
set
{
_predicateOperand = value;
OnPropertyChanged();
}
}
public override string ToString()
{
return PredicateOperator.GetAttributeDescription() + " " + PredicateOperand;
}
public event PropertyChangedEventHandler PropertyChanged;
[NotifyPropertyChangedInvocator]
public virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
{
var handler = PropertyChanged;
if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
}
}
}

937
Filtration.ObjectModel/Properties/Annotations.cs Normal file
View File

@@ -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 { }
}

35
Filtration.ObjectModel/Properties/AssemblyInfo.cs Normal file
View File

@@ -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")]

17
Filtration.ObjectModel/ReplaceColorsParameterSet.cs Normal file
View File

@@ -0,0 +1,17 @@
using System.Windows.Media;
namespace Filtration.ObjectModel
{
public class ReplaceColorsParameterSet
{
public Color OldTextColor { get; set; }
public Color NewTextColor { get; set; }
public Color OldBackgroundColor { get; set; }
public Color NewBackgroundColor { get; set; }
public Color OldBorderColor { get; set; }
public Color NewBorderColor { get; set; }
public bool ReplaceTextColor { get; set; }
public bool ReplaceBackgroundColor { get; set; }
public bool ReplaceBorderColor { get; set; }
}
}