claunia/SabreTools
1
0
Fork 0
mirror of https://github.com/claunia/SabreTools.git synced 2025-12-16 19:14:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add all machine filters (nw)

Browse Source
This commit is contained in:
Matt Nadareski
2020-08-25 14:11:00 -07:00
parent 22cc89b6e8
commit 623651804c
2 changed files with 349 additions and 350 deletions
Download Patch File Download Diff File Expand all files Collapse all files

163
SabreTools.Library/DatItems/Machine.cs
View File

@@ -136,7 +136,6 @@ namespace SabreTools.Library.DatItems
#endregion #endregion
// TODO: Ensure read/write for all fields here
#region ListXML Fields #region ListXML Fields
/// <summary> /// <summary>
@@ -350,7 +349,6 @@ namespace SabreTools.Library.DatItems
#endregion #endregion
// TODO: Ensure read/write for all fields here
#region SoftwareList Fields #region SoftwareList Fields
/// <summary> /// <summary>
@@ -663,76 +661,76 @@ namespace SabreTools.Library.DatItems
#region Common #region Common
// Filter on machine name // Filter on machine name
bool? machineNameFound = filter.MachineName.MatchesPositiveSet(Name); bool? machineNameFound = filter.Machine_Name.MatchesPositiveSet(Name);
if (filter.IncludeOfInGame) if (filter.IncludeOfInGame)
{ {
machineNameFound |= (filter.MachineName.MatchesPositiveSet(CloneOf) == true); machineNameFound |= (filter.Machine_Name.MatchesPositiveSet(CloneOf) == true);
machineNameFound |= (filter.MachineName.MatchesPositiveSet(RomOf) == true); machineNameFound |= (filter.Machine_Name.MatchesPositiveSet(RomOf) == true);
} }
if (machineNameFound == false) if (machineNameFound == false)
return false; return false;
machineNameFound = filter.MachineName.MatchesNegativeSet(Name); machineNameFound = filter.Machine_Name.MatchesNegativeSet(Name);
if (filter.IncludeOfInGame) if (filter.IncludeOfInGame)
{ {
machineNameFound |= (filter.MachineName.MatchesNegativeSet(CloneOf) == true); machineNameFound |= (filter.Machine_Name.MatchesNegativeSet(CloneOf) == true);
machineNameFound |= (filter.MachineName.MatchesNegativeSet(RomOf) == true); machineNameFound |= (filter.Machine_Name.MatchesNegativeSet(RomOf) == true);
} }
if (machineNameFound == false) if (machineNameFound == false)
return false; return false;
// Filter on comment // Filter on comment
if (filter.Comment.MatchesPositiveSet(Comment) == false) if (filter.Machine_Comment.MatchesPositiveSet(Comment) == false)
return false; return false;
if (filter.Comment.MatchesNegativeSet(Comment) == true) if (filter.Machine_Comment.MatchesNegativeSet(Comment) == true)
return false; return false;
// Filter on machine description // Filter on machine description
if (filter.MachineDescription.MatchesPositiveSet(Description) == false) if (filter.Machine_Description.MatchesPositiveSet(Description) == false)
return false; return false;
if (filter.MachineDescription.MatchesNegativeSet(Description) == true) if (filter.Machine_Description.MatchesNegativeSet(Description) == true)
return false; return false;
// Filter on year // Filter on year
if (filter.Year.MatchesPositiveSet(Year) == false) if (filter.Machine_Year.MatchesPositiveSet(Year) == false)
return false; return false;
if (filter.Year.MatchesNegativeSet(Year) == true) if (filter.Machine_Year.MatchesNegativeSet(Year) == true)
return false; return false;
// Filter on manufacturer // Filter on manufacturer
if (filter.Manufacturer.MatchesPositiveSet(Manufacturer) == false) if (filter.Machine_Manufacturer.MatchesPositiveSet(Manufacturer) == false)
return false; return false;
if (filter.Manufacturer.MatchesNegativeSet(Manufacturer) == true) if (filter.Machine_Manufacturer.MatchesNegativeSet(Manufacturer) == true)
return false; return false;
// Filter on publisher // Filter on publisher
if (filter.Publisher.MatchesPositiveSet(Publisher) == false) if (filter.Machine_Publisher.MatchesPositiveSet(Publisher) == false)
return false; return false;
if (filter.Publisher.MatchesNegativeSet(Publisher) == true) if (filter.Machine_Publisher.MatchesNegativeSet(Publisher) == true)
return false; return false;
// Filter on category // Filter on category
if (filter.Category.MatchesPositiveSet(Category) == false) if (filter.Machine_Category.MatchesPositiveSet(Category) == false)
return false; return false;
if (filter.Category.MatchesNegativeSet(Category) == true) if (filter.Machine_Category.MatchesNegativeSet(Category) == true)
return false; return false;
// Filter on romof // Filter on romof
if (filter.RomOf.MatchesPositiveSet(RomOf) == false) if (filter.Machine_RomOf.MatchesPositiveSet(RomOf) == false)
return false; return false;
if (filter.RomOf.MatchesNegativeSet(RomOf) == true) if (filter.Machine_RomOf.MatchesNegativeSet(RomOf) == true)
return false; return false;
// Filter on cloneof // Filter on cloneof
if (filter.CloneOf.MatchesPositiveSet(CloneOf) == false) if (filter.Machine_CloneOf.MatchesPositiveSet(CloneOf) == false)
return false; return false;
if (filter.CloneOf.MatchesNegativeSet(CloneOf) == true) if (filter.Machine_CloneOf.MatchesNegativeSet(CloneOf) == true)
return false; return false;
// Filter on sampleof // Filter on sampleof
if (filter.SampleOf.MatchesPositiveSet(SampleOf) == false) if (filter.Machine_SampleOf.MatchesPositiveSet(SampleOf) == false)
return false; return false;
if (filter.SampleOf.MatchesNegativeSet(SampleOf) == true) if (filter.Machine_SampleOf.MatchesNegativeSet(SampleOf) == true)
return false; return false;
#endregion #endregion
@@ -740,45 +738,45 @@ namespace SabreTools.Library.DatItems
#region AttractMode #region AttractMode
// Filter on players // Filter on players
if (filter.Players.MatchesPositiveSet(Players) == false) if (filter.Machine_Players.MatchesPositiveSet(Players) == false)
return false; return false;
if (filter.Players.MatchesNegativeSet(Players) == true) if (filter.Machine_Players.MatchesNegativeSet(Players) == true)
return false; return false;
// Filter on rotation // Filter on rotation
if (filter.Rotation.MatchesPositiveSet(Rotation) == false) if (filter.Machine_Rotation.MatchesPositiveSet(Rotation) == false)
return false; return false;
if (filter.Rotation.MatchesNegativeSet(Rotation) == true) if (filter.Machine_Rotation.MatchesNegativeSet(Rotation) == true)
return false; return false;
// Filter on control // Filter on control
if (filter.Control.MatchesPositiveSet(Control) == false) if (filter.Machine_Control.MatchesPositiveSet(Control) == false)
return false; return false;
if (filter.Control.MatchesNegativeSet(Control) == true) if (filter.Machine_Control.MatchesNegativeSet(Control) == true)
return false; return false;
// Filter on support status // Filter on support status
if (filter.SupportStatus.MatchesPositiveSet(Status) == false) if (filter.Machine_Status.MatchesPositiveSet(Status) == false)
return false; return false;
if (filter.SupportStatus.MatchesNegativeSet(Status) == true) if (filter.Machine_Status.MatchesNegativeSet(Status) == true)
return false; return false;
// Filter on display count // Filter on display count
if (filter.DisplayCount.MatchesPositiveSet(DisplayCount) == false) if (filter.Machine_DisplayCount.MatchesPositiveSet(DisplayCount) == false)
return false; return false;
if (filter.DisplayCount.MatchesNegativeSet(DisplayCount) == true) if (filter.Machine_DisplayCount.MatchesNegativeSet(DisplayCount) == true)
return false; return false;
// Filter on display type // Filter on display type
if (filter.DisplayType.MatchesPositiveSet(DisplayType) == false) if (filter.Machine_DisplayType.MatchesPositiveSet(DisplayType) == false)
return false; return false;
if (filter.DisplayType.MatchesNegativeSet(DisplayType) == true) if (filter.Machine_DisplayType.MatchesNegativeSet(DisplayType) == true)
return false; return false;
// Filter on buttons // Filter on buttons
if (filter.Buttons.MatchesPositiveSet(Buttons) == false) if (filter.Machine_Buttons.MatchesPositiveSet(Buttons) == false)
return false; return false;
if (filter.Buttons.MatchesNegativeSet(Buttons) == true) if (filter.Machine_Buttons.MatchesNegativeSet(Buttons) == true)
return false; return false;
#endregion #endregion
@@ -786,38 +784,23 @@ namespace SabreTools.Library.DatItems
#region ListXML #region ListXML
// Filter on source file // Filter on source file
if (filter.SourceFile.MatchesPositiveSet(SourceFile) == false) if (filter.Machine_SourceFile.MatchesPositiveSet(SourceFile) == false)
return false; return false;
if (filter.SourceFile.MatchesNegativeSet(SourceFile) == true) if (filter.Machine_SourceFile.MatchesNegativeSet(SourceFile) == true)
return false; return false;
// Filter on runnable // Filter on runnable
if (filter.Runnables.MatchesPositive(Runnable.NULL, Runnable) == false) if (filter.Machine_Runnable.MatchesPositive(Runnable.NULL, Runnable) == false)
return false; return false;
if (filter.Runnables.MatchesNegative(Runnable.NULL, Runnable) == true) if (filter.Machine_Runnable.MatchesNegative(Runnable.NULL, Runnable) == true)
return false; return false;
// Filter on devices
if (DeviceReferences != null && DeviceReferences.Any())
{
bool anyPositiveDevice = false;
bool anyNegativeDevice = false;
foreach (ListXmlDeviceReference device in DeviceReferences)
{
anyPositiveDevice |= filter.Devices.MatchesPositiveSet(device.Name) != false;
anyNegativeDevice |= filter.Devices.MatchesNegativeSet(device.Name) == false;
}
if (!anyPositiveDevice || anyNegativeDevice)
return false;
}
// TODO: Add Slot filter // TODO: Add Slot filter
// Filter on machine type // Filter on machine type
if (filter.MachineTypes.MatchesPositive(MachineType.NULL, MachineType) == false) if (filter.Machine_Type.MatchesPositive(MachineType.NULL, MachineType) == false)
return false; return false;
if (filter.MachineTypes.MatchesNegative(MachineType.NULL, MachineType) == true) if (filter.Machine_Type.MatchesNegative(MachineType.NULL, MachineType) == true)
return false; return false;
#endregion #endregion
@@ -825,15 +808,15 @@ namespace SabreTools.Library.DatItems
#region Logiqx #region Logiqx
// Filter on board // Filter on board
if (filter.Board.MatchesPositiveSet(Board) == false) if (filter.Machine_Board.MatchesPositiveSet(Board) == false)
return false; return false;
if (filter.Board.MatchesNegativeSet(Board) == true) if (filter.Machine_Board.MatchesNegativeSet(Board) == true)
return false; return false;
// Filter on rebuildto // Filter on rebuildto
if (filter.RebuildTo.MatchesPositiveSet(RebuildTo) == false) if (filter.Machine_RebuildTo.MatchesPositiveSet(RebuildTo) == false)
return false; return false;
if (filter.RebuildTo.MatchesNegativeSet(RebuildTo) == true) if (filter.Machine_RebuildTo.MatchesNegativeSet(RebuildTo) == true)
return false; return false;
#endregion #endregion
@@ -841,55 +824,55 @@ namespace SabreTools.Library.DatItems
#region Logiqx EmuArc #region Logiqx EmuArc
// Filter on title ID // Filter on title ID
if (filter.TitleID.MatchesPositiveSet(TitleID) == false) if (filter.Machine_TitleID.MatchesPositiveSet(TitleID) == false)
return false; return false;
if (filter.TitleID.MatchesNegativeSet(TitleID) == true) if (filter.Machine_TitleID.MatchesNegativeSet(TitleID) == true)
return false; return false;
// Filter on developer // Filter on developer
if (filter.Developer.MatchesPositiveSet(Developer) == false) if (filter.Machine_Developer.MatchesPositiveSet(Developer) == false)
return false; return false;
if (filter.Developer.MatchesNegativeSet(Developer) == true) if (filter.Machine_Developer.MatchesNegativeSet(Developer) == true)
return false; return false;
// Filter on genre // Filter on genre
if (filter.Genre.MatchesPositiveSet(Genre) == false) if (filter.Machine_Genre.MatchesPositiveSet(Genre) == false)
return false; return false;
if (filter.Genre.MatchesNegativeSet(Genre) == true) if (filter.Machine_Genre.MatchesNegativeSet(Genre) == true)
return false; return false;
// Filter on rebuildto // Filter on rebuildto
if (filter.Subgenre.MatchesPositiveSet(Subgenre) == false) if (filter.Machine_Subgenre.MatchesPositiveSet(Subgenre) == false)
return false; return false;
if (filter.Subgenre.MatchesNegativeSet(Subgenre) == true) if (filter.Machine_Subgenre.MatchesNegativeSet(Subgenre) == true)
return false; return false;
// Filter on subgenre // Filter on subgenre
if (filter.Ratings.MatchesPositiveSet(Ratings) == false) if (filter.Machine_Ratings.MatchesPositiveSet(Ratings) == false)
return false; return false;
if (filter.Ratings.MatchesNegativeSet(Ratings) == true) if (filter.Machine_Ratings.MatchesNegativeSet(Ratings) == true)
return false; return false;
// Filter on score // Filter on score
if (filter.Score.MatchesPositiveSet(Score) == false) if (filter.Machine_Score.MatchesPositiveSet(Score) == false)
return false; return false;
if (filter.Score.MatchesNegativeSet(Score) == true) if (filter.Machine_Score.MatchesNegativeSet(Score) == true)
return false; return false;
// Filter on enabled // Filter on enabled
if (filter.Enabled.MatchesPositiveSet(Enabled) == false) if (filter.Machine_Enabled.MatchesPositiveSet(Enabled) == false)
return false; return false;
if (filter.Enabled.MatchesNegativeSet(Enabled) == true) if (filter.Machine_Enabled.MatchesNegativeSet(Enabled) == true)
return false; return false;
// Filter on has CRC flag // Filter on has CRC flag
if (filter.HasCrc.MatchesNeutral(null, HasCrc) == false) if (filter.Machine_CRC.MatchesNeutral(null, HasCrc) == false)
return false; return false;
// Filter on related to // Filter on related to
if (filter.RelatedTo.MatchesPositiveSet(RelatedTo) == false) if (filter.Machine_RelatedTo.MatchesPositiveSet(RelatedTo) == false)
return false; return false;
if (filter.RelatedTo.MatchesNegativeSet(RelatedTo) == true) if (filter.Machine_RelatedTo.MatchesNegativeSet(RelatedTo) == true)
return false; return false;
#endregion #endregion
@@ -897,21 +880,21 @@ namespace SabreTools.Library.DatItems
#region OpenMSX #region OpenMSX
// Filter on Generation MSX ID // Filter on Generation MSX ID
if (filter.GenMSXID.MatchesPositiveSet(GenMSXID) == false) if (filter.Machine_GenMSXID.MatchesPositiveSet(GenMSXID) == false)
return false; return false;
if (filter.GenMSXID.MatchesNegativeSet(GenMSXID) == true) if (filter.Machine_GenMSXID.MatchesNegativeSet(GenMSXID) == true)
return false; return false;
// Filter on system // Filter on system
if (filter.System.MatchesPositiveSet(System) == false) if (filter.Machine_System.MatchesPositiveSet(System) == false)
return false; return false;
if (filter.System.MatchesNegativeSet(System) == true) if (filter.Machine_System.MatchesNegativeSet(System) == true)
return false; return false;
// Filter on country // Filter on country
if (filter.Country.MatchesPositiveSet(Country) == false) if (filter.Machine_Country.MatchesPositiveSet(Country) == false)
return false; return false;
if (filter.Country.MatchesNegativeSet(Country) == true) if (filter.Machine_Country.MatchesNegativeSet(Country) == true)
return false; return false;
#endregion #endregion
@@ -919,9 +902,9 @@ namespace SabreTools.Library.DatItems
#region SoftwareList #region SoftwareList
// Filter on supported // Filter on supported
if (filter.SupportedStatus.MatchesPositive(Supported.NULL, Supported) == false) if (filter.Machine_Supported.MatchesPositive(Supported.NULL, Supported) == false)
return false; return false;
if (filter.SupportedStatus.MatchesNegative(Supported.NULL, Supported) == true) if (filter.Machine_Supported.MatchesNegative(Supported.NULL, Supported) == true)
return false; return false;
#endregion #endregion

536
SabreTools.Library/Filtering/Filter.cs
View File

@@ -21,218 +21,248 @@ namespace SabreTools.Library.Filtering
#region Common #region Common
/// <summary> public FilterItem<string> Machine_Name { get; private set; } = new FilterItem<string>();
/// Include or exclude machine names public FilterItem<string> Machine_Comment { get; private set; } = new FilterItem<string>();
/// </summary> public FilterItem<string> Machine_Description { get; private set; } = new FilterItem<string>();
public FilterItem<string> MachineName { get; private set; } = new FilterItem<string>(); public FilterItem<string> Machine_Year { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Manufacturer { get; private set; } = new FilterItem<string>();
/// <summary> public FilterItem<string> Machine_Publisher { get; private set; } = new FilterItem<string>();
/// Include or exclude machine comments public FilterItem<string> Machine_Category { get; private set; } = new FilterItem<string>();
/// </summary> public FilterItem<string> Machine_RomOf { get; private set; } = new FilterItem<string>();
public FilterItem<string> Comment { get; private set; } = new FilterItem<string>(); public FilterItem<string> Machine_CloneOf { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_SampleOf { get; private set; } = new FilterItem<string>();
/// <summary> public FilterItem<MachineType> Machine_Type { get; private set; } = new FilterItem<MachineType>() { Positive = MachineType.NULL, Negative = MachineType.NULL };
/// Include or exclude machine descriptions
/// </summary>
public FilterItem<string> MachineDescription { get; private set; } = new FilterItem<string>();
/// <summary>
/// Include or exclude machine years
/// </summary>
public FilterItem<string> Year { get; private set; } = new FilterItem<string>();
/// <summary>
/// Include or exclude machine manufacturers
/// </summary>
public FilterItem<string> Manufacturer { get; private set; } = new FilterItem<string>();
/// <summary>
/// Include or exclude machine publishers
/// </summary>
public FilterItem<string> Publisher { get; private set; } = new FilterItem<string>();
/// <summary>
/// Include or exclude machine categories
/// </summary>
public FilterItem<string> Category { get; private set; } = new FilterItem<string>();
/// <summary>
/// Include or exclude machine romof
/// </summary>
public FilterItem<string> RomOf { get; private set; } = new FilterItem<string>();
/// <summary>
/// Include or exclude machine cloneof
/// </summary>
public FilterItem<string> CloneOf { get; private set; } = new FilterItem<string>();
/// <summary>
/// Include or exclude machine sampleof
/// </summary>
public FilterItem<string> SampleOf { get; private set; } = new FilterItem<string>();
#endregion #endregion
#region AttractMode #region AttractMode
/// <summary> public FilterItem<string> Machine_Players { get; private set; } = new FilterItem<string>();
/// Include or exclude machine players public FilterItem<string> Machine_Rotation { get; private set; } = new FilterItem<string>();
/// </summary> public FilterItem<string> Machine_Control { get; private set; } = new FilterItem<string>();
public FilterItem<string> Players { get; private set; } = new FilterItem<string>(); public FilterItem<string> Machine_Status { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_DisplayCount { get; private set; } = new FilterItem<string>();
/// <summary> public FilterItem<string> Machine_DisplayType { get; private set; } = new FilterItem<string>();
/// Include or exclude machine rotation public FilterItem<string> Machine_Buttons { get; private set; } = new FilterItem<string>();
/// </summary>
public FilterItem<string> Rotation { get; private set; } = new FilterItem<string>();
/// <summary>
/// Include or exclude machine control
/// </summary>
public FilterItem<string> Control { get; private set; } = new FilterItem<string>();
/// <summary>
/// Include or exclude machine support status
/// </summary>
public FilterItem<string> SupportStatus { get; private set; } = new FilterItem<string>();
/// <summary>
/// Include or exclude machine display count
/// </summary>
public FilterItem<string> DisplayCount { get; private set; } = new FilterItem<string>();
/// <summary>
/// Include or exclude machine display type
/// </summary>
public FilterItem<string> DisplayType { get; private set; } = new FilterItem<string>();
/// <summary>
/// Include or exclude machine buttons
/// </summary>
public FilterItem<string> Buttons { get; private set; } = new FilterItem<string>();
#endregion #endregion
#region ListXML #region ListXML
/// <summary> public FilterItem<string> Machine_SourceFile { get; private set; } = new FilterItem<string>();
/// Include or exclude machine source file public FilterItem<Runnable> Machine_Runnable { get; private set; } = new FilterItem<Runnable>() { Positive = Runnable.NULL, Negative = Runnable.NULL };
/// </summary>
public FilterItem<string> SourceFile { get; private set; } = new FilterItem<string>();
/// <summary> // DeviceReferences
/// Include or exclude items with the "Runnable" tag public FilterItem<bool?> Machine_DeviceReferences { get; private set; } = new FilterItem<bool?>() { Neutral = null };
/// </summary> public FilterItem<string> Machine_DeviceReference_Name { get; private set; } = new FilterItem<string>();
public FilterItem<Runnable> Runnables { get; private set; } = new FilterItem<Runnable>() { Positive = Runnable.NULL, Negative = Runnable.NULL };
/// <summary> // Chips
/// Include or exclude machine devices public FilterItem<bool?> Machine_Chips { get; private set; } = new FilterItem<bool?>() { Neutral = null };
/// </summary> public FilterItem<string> Machine_Chip_Name { get; private set; } = new FilterItem<string>();
public FilterItem<string> Devices { get; private set; } = new FilterItem<string>(); public FilterItem<string> Machine_Chip_Tag { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Chip_Type { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Chip_Clock { get; private set; } = new FilterItem<string>();
/// <summary> // Displays
/// Include or exclude machine slotoptions public FilterItem<bool?> Machine_Displays { get; private set; } = new FilterItem<bool?>() { Neutral = null };
/// </summary> public FilterItem<string> Machine_Display_Tag { get; private set; } = new FilterItem<string>();
public FilterItem<string> SlotOptions { get; private set; } = new FilterItem<string>(); public FilterItem<string> Machine_Display_Type { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Display_Rotate { get; private set; } = new FilterItem<string>();
public FilterItem<bool?> Machine_Display_FlipX { get; private set; } = new FilterItem<bool?>() { Neutral = null };
public FilterItem<string> Machine_Display_Width { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Display_Height { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Display_Refresh { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Display_PixClock { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Display_HTotal { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Display_HBEnd { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Display_HBStart { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Display_VTotal { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Display_VBEnd { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Display_VBStart { get; private set; } = new FilterItem<string>();
// TODO: Machine.Infos - List<ListXmlInfo> // Sounds
public FilterItem<bool?> Machine_Sounds { get; private set; } = new FilterItem<bool?>() { Neutral = null };
public FilterItem<string> Machine_Sound_Channels { get; private set; } = new FilterItem<string>();
/// <summary> // Conditions
/// Include or exclude machine types public FilterItem<bool?> Machine_Conditions { get; private set; } = new FilterItem<bool?>() { Neutral = null };
/// </summary> public FilterItem<string> Machine_Condition_Tag { get; private set; } = new FilterItem<string>();
public FilterItem<MachineType> MachineTypes { get; private set; } = new FilterItem<MachineType>() { Positive = MachineType.NULL, Negative = MachineType.NULL }; public FilterItem<string> Machine_Condition_Mask { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Condition_Relation { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Condition_Value { get; private set; } = new FilterItem<string>();
// Inputs
public FilterItem<bool?> Machine_Inputs { get; private set; } = new FilterItem<bool?>() { Neutral = null };
public FilterItem<bool?> Machine_Input_Service { get; private set; } = new FilterItem<bool?>() { Neutral = null };
public FilterItem<bool?> Machine_Input_Tilt { get; private set; } = new FilterItem<bool?>() { Neutral = null };
public FilterItem<string> Machine_Input_Players { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Input_Coins { get; private set; } = new FilterItem<string>();
// Inputs.Controls
public FilterItem<bool?> Machine_Input_Controls { get; private set; } = new FilterItem<bool?>() { Neutral = null };
public FilterItem<string> Machine_Input_Control_Type { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Input_Control_Player { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Input_Control_Buttons { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Input_Control_RegButtons { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Input_Control_Minimum { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Input_Control_Maximum { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Input_Control_Sensitivity { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Input_Control_KeyDelta { get; private set; } = new FilterItem<string>();
public FilterItem<bool?> Machine_Input_Control_Reverse { get; private set; } = new FilterItem<bool?>() { Neutral = null };
public FilterItem<string> Machine_Input_Control_Ways { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Input_Control_Ways2 { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Input_Control_Ways3 { get; private set; } = new FilterItem<string>();
// DipSwitches
public FilterItem<bool?> Machine_DipSwitches { get; private set; } = new FilterItem<bool?>() { Neutral = null };
public FilterItem<string> Machine_DipSwitch_Name { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_DipSwitch_Tag { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_DipSwitch_Mask { get; private set; } = new FilterItem<string>();
// DipSwitches.Locations
public FilterItem<bool?> Machine_DipSwitch_Locations { get; private set; } = new FilterItem<bool?>() { Neutral = null };
public FilterItem<string> Machine_DipSwitch_Location_Name { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_DipSwitch_Location_Number { get; private set; } = new FilterItem<string>();
public FilterItem<bool?> Machine_DipSwitch_Location_Inverted { get; private set; } = new FilterItem<bool?>() { Neutral = null };
// DipSwitches.Values
public FilterItem<bool?> Machine_DipSwitch_Values { get; private set; } = new FilterItem<bool?>() { Neutral = null };
public FilterItem<string> Machine_DipSwitch_Value_Name { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_DipSwitch_Value_Value { get; private set; } = new FilterItem<string>();
public FilterItem<bool?> Machine_DipSwitch_Value_Default { get; private set; } = new FilterItem<bool?>() { Neutral = null };
// Configurations
public FilterItem<bool?> Machine_Configurations { get; private set; } = new FilterItem<bool?>() { Neutral = null };
public FilterItem<string> Machine_Configuration_Name { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Configuration_Tag { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Configuration_Mask { get; private set; } = new FilterItem<string>();
// Configurations.Locations
public FilterItem<bool?> Machine_Configuration_Locations { get; private set; } = new FilterItem<bool?>() { Neutral = null };
public FilterItem<string> Machine_Configuration_Location_Name { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Configuration_Location_Number { get; private set; } = new FilterItem<string>();
public FilterItem<bool?> Machine_Configuration_Location_Inverted { get; private set; } = new FilterItem<bool?>() { Neutral = null };
// Configurations.Settings
public FilterItem<bool?> Machine_Configuration_Settings { get; private set; } = new FilterItem<bool?>() { Neutral = null };
public FilterItem<string> Machine_Configuration_Setting_Name { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Configuration_Setting_Value { get; private set; } = new FilterItem<string>();
public FilterItem<bool?> Machine_Configuration_Setting_Default { get; private set; } = new FilterItem<bool?>() { Neutral = null };
// Ports
public FilterItem<bool?> Machine_Ports { get; private set; } = new FilterItem<bool?>() { Neutral = null };
public FilterItem<string> Machine_Port_Tag { get; private set; } = new FilterItem<string>();
// Ports.Analogs
public FilterItem<bool?> Machine_Port_Analogs { get; private set; } = new FilterItem<bool?>() { Neutral = null };
public FilterItem<string> Machine_Port_Analog_Mask { get; private set; } = new FilterItem<string>();
// Adjusters
public FilterItem<bool?> Machine_Adjusters { get; private set; } = new FilterItem<bool?>() { Neutral = null };
public FilterItem<string> Machine_Adjuster_Name { get; private set; } = new FilterItem<string>();
public FilterItem<bool?> Machine_Adjuster_Default { get; private set; } = new FilterItem<bool?>() { Neutral = null };
// Adjusters.Conditions
public FilterItem<bool?> Machine_Adjuster_Conditions { get; private set; } = new FilterItem<bool?>() { Neutral = null };
public FilterItem<string> Machine_Adjuster_Condition_Tag { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Adjuster_Condition_Mask { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Adjuster_Condition_Relation { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Adjuster_Condition_Value { get; private set; } = new FilterItem<string>();
// Drivers
public FilterItem<bool?> Machine_Drivers { get; private set; } = new FilterItem<bool?>() { Neutral = null };
public FilterItem<string> Machine_Driver_Status { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Driver_Emulation { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Driver_Cocktail { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Driver_SaveState { get; private set; } = new FilterItem<string>();
// Features
public FilterItem<bool?> Machine_Features { get; private set; } = new FilterItem<bool?>() { Neutral = null };
public FilterItem<string> Machine_Feature_Type { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Feature_Status { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Feature_Overall { get; private set; } = new FilterItem<string>();
// Devices
public FilterItem<bool?> Machine_Devices { get; private set; } = new FilterItem<bool?>() { Neutral = null };
public FilterItem<string> Machine_Device_Type { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Device_Tag { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Device_FixedImage { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Device_Mandatory { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Device_Interface { get; private set; } = new FilterItem<string>();
// Devices.Instances
public FilterItem<bool?> Machine_Device_Instances { get; private set; } = new FilterItem<bool?>() { Neutral = null };
public FilterItem<string> Machine_Device_Instance_Name { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Device_Instance_BriefName { get; private set; } = new FilterItem<string>();
// Devices.Extensions
public FilterItem<bool?> Machine_Device_Extensions { get; private set; } = new FilterItem<bool?>() { Neutral = null };
public FilterItem<string> Machine_Device_Extension_Name { get; private set; } = new FilterItem<string>();
// Slots
public FilterItem<bool?> Machine_Slots { get; private set; } = new FilterItem<bool?>() { Neutral = null };
public FilterItem<string> Machine_Slot_Name { get; private set; } = new FilterItem<string>();
// Slots.SlotOptions
public FilterItem<bool?> Machine_Slot_SlotOptions { get; private set; } = new FilterItem<bool?>() { Neutral = null };
public FilterItem<string> Machine_Slot_SlotOption_Name { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Slot_SlotOption_DeviceName { get; private set; } = new FilterItem<string>();
public FilterItem<bool?> Machine_Slot_SlotOption_Default { get; private set; } = new FilterItem<bool?>() { Neutral = null };
// SoftwareLists
public FilterItem<bool?> Machine_SoftwareLists { get; private set; } = new FilterItem<bool?>() { Neutral = null };
public FilterItem<string> Machine_SoftwareList_Name { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_SoftwareList_Status { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_SoftwareList_Filter { get; private set; } = new FilterItem<string>();
// RamOptions
public FilterItem<bool?> Machine_RamOptions { get; private set; } = new FilterItem<bool?>() { Neutral = null };
public FilterItem<bool?> Machine_RamOption_Default { get; private set; } = new FilterItem<bool?>() { Neutral = null };
#endregion #endregion
#region Logiqx #region Logiqx
/// <summary> public FilterItem<string> Machine_Board { get; private set; } = new FilterItem<string>();
/// Include or exclude machine board public FilterItem<string> Machine_RebuildTo { get; private set; } = new FilterItem<string>();
/// </summary>
public FilterItem<string> Board { get; private set; } = new FilterItem<string>();
/// <summary>
/// Include or exclude machine rebuildto
/// </summary>
public FilterItem<string> RebuildTo { get; private set; } = new FilterItem<string>();
#endregion #endregion
#region Logiqx EmuArc #region Logiqx EmuArc
/// <summary> public FilterItem<string> Machine_TitleID { get; private set; } = new FilterItem<string>();
/// Include or exclude machine title ID public FilterItem<string> Machine_Developer { get; private set; } = new FilterItem<string>();
/// </summary> public FilterItem<string> Machine_Genre { get; private set; } = new FilterItem<string>();
public FilterItem<string> TitleID { get; private set; } = new FilterItem<string>(); public FilterItem<string> Machine_Subgenre { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Ratings { get; private set; } = new FilterItem<string>();
/// <summary> public FilterItem<string> Machine_Score { get; private set; } = new FilterItem<string>();
/// Include or exclude machine developer public FilterItem<string> Machine_Enabled { get; private set; } = new FilterItem<string>();
/// </summary> public FilterItem<bool?> Machine_CRC { get; private set; } = new FilterItem<bool?>() { Neutral = null };
public FilterItem<string> Developer { get; private set; } = new FilterItem<string>(); public FilterItem<string> Machine_RelatedTo { get; private set; } = new FilterItem<string>();
/// <summary>
/// Include or exclude machine genre
/// </summary>
public FilterItem<string> Genre { get; private set; } = new FilterItem<string>();
/// <summary>
/// Include or exclude machine subgenre
/// </summary>
public FilterItem<string> Subgenre { get; private set; } = new FilterItem<string>();
/// <summary>
/// Include or exclude machine ratings
/// </summary>
public FilterItem<string> Ratings { get; private set; } = new FilterItem<string>();
/// <summary>
/// Include or exclude machine score
/// </summary>
public FilterItem<string> Score { get; private set; } = new FilterItem<string>();
/// <summary>
/// Include or exclude machine enabled
/// </summary>
public FilterItem<string> Enabled { get; private set; } = new FilterItem<string>();
/// <summary>
/// Include or exclude items with the "crc" tag
/// </summary>
public FilterItem<bool?> HasCrc { get; private set; } = new FilterItem<bool?>() { Neutral = null };
/// <summary>
/// Include or exclude machine related to
/// </summary>
public FilterItem<string> RelatedTo { get; private set; } = new FilterItem<string>();
#endregion #endregion
#region OpenMSX #region OpenMSX
/// <summary> public FilterItem<string> Machine_GenMSXID { get; private set; } = new FilterItem<string>();
/// Include or exclude machine Generation MSX ID public FilterItem<string> Machine_System { get; private set; } = new FilterItem<string>();
/// </summary> public FilterItem<string> Machine_Country { get; private set; } = new FilterItem<string>();
public FilterItem<string> GenMSXID { get; private set; } = new FilterItem<string>();
/// <summary>
/// Include or exclude machine system
/// </summary>
public FilterItem<string> System { get; private set; } = new FilterItem<string>();
/// <summary>
/// Include or exclude machine country
/// </summary>
public FilterItem<string> Country { get; private set; } = new FilterItem<string>();
#endregion #endregion
#region SoftwareList #region SoftwareList
/// <summary> public FilterItem<Supported> Machine_Supported { get; private set; } = new FilterItem<Supported>() { Positive = Supported.NULL, Negative = Supported.NULL };
/// Include or exclude items with the "Supported" tag
/// </summary>
public FilterItem<Supported> SupportedStatus { get; private set; } = new FilterItem<Supported>() { Positive = Supported.NULL, Negative = Supported.NULL };
// TODO: Machine.SharedFeatures - List<SoftwareListSharedFeature> // Infos
public FilterItem<bool?> Machine_Infos { get; private set; } = new FilterItem<bool?>() { Neutral = null };
public FilterItem<string> Machine_Info_Name { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_Info_Value { get; private set; } = new FilterItem<string>();
// SharedFeatures
public FilterItem<bool?> Machine_SharedFeatures { get; private set; } = new FilterItem<bool?>() { Neutral = null };
public FilterItem<string> Machine_SharedFeature_Name { get; private set; } = new FilterItem<string>();
public FilterItem<string> Machine_SharedFeature_Value { get; private set; } = new FilterItem<string>();
#endregion #endregion
@@ -564,79 +594,79 @@ namespace SabreTools.Library.Filtering
case Field.Machine_Name: case Field.Machine_Name:
if (negate) if (negate)
MachineName.NegativeSet.Add(value); Machine_Name.NegativeSet.Add(value);
else else
MachineName.PositiveSet.Add(value); Machine_Name.PositiveSet.Add(value);
break; break;
case Field.Machine_Comment: case Field.Machine_Comment:
if (negate) if (negate)
Comment.NegativeSet.Add(value); Machine_Comment.NegativeSet.Add(value);
else else
Comment.PositiveSet.Add(value); Machine_Comment.PositiveSet.Add(value);
break; break;
case Field.Machine_Description: case Field.Machine_Description:
if (negate) if (negate)
MachineDescription.NegativeSet.Add(value); Machine_Description.NegativeSet.Add(value);
else else
MachineDescription.PositiveSet.Add(value); Machine_Description.PositiveSet.Add(value);
break; break;
case Field.Machine_Year: case Field.Machine_Year:
if (negate) if (negate)
Year.NegativeSet.Add(value); Machine_Year.NegativeSet.Add(value);
else else
Year.PositiveSet.Add(value); Machine_Year.PositiveSet.Add(value);
break; break;
case Field.Machine_Manufacturer: case Field.Machine_Manufacturer:
if (negate) if (negate)
Manufacturer.NegativeSet.Add(value); Machine_Manufacturer.NegativeSet.Add(value);
else else
Manufacturer.PositiveSet.Add(value); Machine_Manufacturer.PositiveSet.Add(value);
break; break;
case Field.Machine_Publisher: case Field.Machine_Publisher:
if (negate) if (negate)
Publisher.NegativeSet.Add(value); Machine_Publisher.NegativeSet.Add(value);
else else
Publisher.PositiveSet.Add(value); Machine_Publisher.PositiveSet.Add(value);
break; break;
case Field.Machine_Category: case Field.Machine_Category:
if (negate) if (negate)
Category.NegativeSet.Add(value); Machine_Category.NegativeSet.Add(value);
else else
Category.PositiveSet.Add(value); Machine_Category.PositiveSet.Add(value);
break; break;
case Field.Machine_RomOf: case Field.Machine_RomOf:
if (negate) if (negate)
RomOf.NegativeSet.Add(value); Machine_RomOf.NegativeSet.Add(value);
else else
RomOf.PositiveSet.Add(value); Machine_RomOf.PositiveSet.Add(value);
break; break;
case Field.Machine_CloneOf: case Field.Machine_CloneOf:
if (negate) if (negate)
CloneOf.NegativeSet.Add(value); Machine_CloneOf.NegativeSet.Add(value);
else else
CloneOf.PositiveSet.Add(value); Machine_CloneOf.PositiveSet.Add(value);
break; break;
case Field.Machine_SampleOf: case Field.Machine_SampleOf:
if (negate) if (negate)
SampleOf.NegativeSet.Add(value); Machine_SampleOf.NegativeSet.Add(value);
else else
SampleOf.PositiveSet.Add(value); Machine_SampleOf.PositiveSet.Add(value);
break; break;
case Field.Machine_Type: case Field.Machine_Type:
if (negate) if (negate)
MachineTypes.Negative |= value.AsMachineType(); Machine_Type.Negative |= value.AsMachineType();
else else
MachineTypes.Positive |= value.AsMachineType(); Machine_Type.Positive |= value.AsMachineType();
break; break;
#endregion #endregion
@@ -645,51 +675,51 @@ namespace SabreTools.Library.Filtering
case Field.Machine_Players: case Field.Machine_Players:
if (negate) if (negate)
Players.NegativeSet.Add(value); Machine_Players.NegativeSet.Add(value);
else else
Players.PositiveSet.Add(value); Machine_Players.PositiveSet.Add(value);
break; break;
case Field.Machine_Rotation: case Field.Machine_Rotation:
if (negate) if (negate)
Rotation.NegativeSet.Add(value); Machine_Rotation.NegativeSet.Add(value);
else else
Rotation.PositiveSet.Add(value); Machine_Rotation.PositiveSet.Add(value);
break; break;
case Field.Machine_Control: case Field.Machine_Control:
if (negate) if (negate)
Control.NegativeSet.Add(value); Machine_Control.NegativeSet.Add(value);
else else
Control.PositiveSet.Add(value); Machine_Control.PositiveSet.Add(value);
break; break;
case Field.Machine_Status: case Field.Machine_Status:
if (negate) if (negate)
SupportStatus.NegativeSet.Add(value); Machine_Status.NegativeSet.Add(value);
else else
SupportStatus.PositiveSet.Add(value); Machine_Status.PositiveSet.Add(value);
break; break;
case Field.Machine_DisplayCount: case Field.Machine_DisplayCount:
if (negate) if (negate)
DisplayCount.NegativeSet.Add(value); Machine_DisplayCount.NegativeSet.Add(value);
else else
DisplayCount.PositiveSet.Add(value); Machine_DisplayCount.PositiveSet.Add(value);
break; break;
case Field.Machine_DisplayType: case Field.Machine_DisplayType:
if (negate) if (negate)
DisplayType.NegativeSet.Add(value); Machine_DisplayType.NegativeSet.Add(value);
else else
DisplayType.PositiveSet.Add(value); Machine_DisplayType.PositiveSet.Add(value);
break; break;
case Field.Machine_Buttons: case Field.Machine_Buttons:
if (negate) if (negate)
Buttons.NegativeSet.Add(value); Machine_Buttons.NegativeSet.Add(value);
else else
Buttons.PositiveSet.Add(value); Machine_Buttons.PositiveSet.Add(value);
break; break;
#endregion #endregion
@@ -698,30 +728,16 @@ namespace SabreTools.Library.Filtering
case Field.Machine_SourceFile: case Field.Machine_SourceFile:
if (negate) if (negate)
SourceFile.NegativeSet.Add(value); Machine_SourceFile.NegativeSet.Add(value);
else else
SourceFile.PositiveSet.Add(value); Machine_SourceFile.PositiveSet.Add(value);
break; break;
case Field.Machine_Runnable: case Field.Machine_Runnable:
if (negate) if (negate)
Runnables.Negative |= value.AsRunnable(); Machine_Runnable.Negative |= value.AsRunnable();
else else
Runnables.Positive |= value.AsRunnable(); Machine_Runnable.Positive |= value.AsRunnable();
break;
case Field.Machine_DeviceReference_Name:
if (negate)
Devices.NegativeSet.Add(value);
else
Devices.PositiveSet.Add(value);
break;
case Field.Machine_Slots:
if (negate)
SlotOptions.NegativeSet.Add(value);
else
SlotOptions.PositiveSet.Add(value);
break; break;
#endregion #endregion
@@ -730,16 +746,16 @@ namespace SabreTools.Library.Filtering
case Field.Machine_Board: case Field.Machine_Board:
if (negate) if (negate)
Board.NegativeSet.Add(value); Machine_Board.NegativeSet.Add(value);
else else
Board.PositiveSet.Add(value); Machine_Board.PositiveSet.Add(value);
break; break;
case Field.Machine_RebuildTo: case Field.Machine_RebuildTo:
if (negate) if (negate)
RebuildTo.NegativeSet.Add(value); Machine_RebuildTo.NegativeSet.Add(value);
else else
RebuildTo.PositiveSet.Add(value); Machine_RebuildTo.PositiveSet.Add(value);
break; break;
#endregion #endregion
@@ -748,65 +764,65 @@ namespace SabreTools.Library.Filtering
case Field.Machine_TitleID: case Field.Machine_TitleID:
if (negate) if (negate)
TitleID.NegativeSet.Add(value); Machine_TitleID.NegativeSet.Add(value);
else else
TitleID.PositiveSet.Add(value); Machine_TitleID.PositiveSet.Add(value);
break; break;
case Field.Machine_Developer: case Field.Machine_Developer:
if (negate) if (negate)
Developer.NegativeSet.Add(value); Machine_Developer.NegativeSet.Add(value);
else else
Developer.PositiveSet.Add(value); Machine_Developer.PositiveSet.Add(value);
break; break;
case Field.Machine_Genre: case Field.Machine_Genre:
if (negate) if (negate)
Genre.NegativeSet.Add(value); Machine_Genre.NegativeSet.Add(value);
else else
Genre.PositiveSet.Add(value); Machine_Genre.PositiveSet.Add(value);
break; break;
case Field.Machine_Subgenre: case Field.Machine_Subgenre:
if (negate) if (negate)
Subgenre.NegativeSet.Add(value); Machine_Subgenre.NegativeSet.Add(value);
else else
Subgenre.PositiveSet.Add(value); Machine_Subgenre.PositiveSet.Add(value);
break; break;
case Field.Machine_Ratings: case Field.Machine_Ratings:
if (negate) if (negate)
Ratings.NegativeSet.Add(value); Machine_Ratings.NegativeSet.Add(value);
else else
Ratings.PositiveSet.Add(value); Machine_Ratings.PositiveSet.Add(value);
break; break;
case Field.Machine_Score: case Field.Machine_Score:
if (negate) if (negate)
Score.NegativeSet.Add(value); Machine_Score.NegativeSet.Add(value);
else else
Score.PositiveSet.Add(value); Machine_Score.PositiveSet.Add(value);
break; break;
case Field.Machine_Enabled: case Field.Machine_Enabled:
if (negate) if (negate)
Enabled.NegativeSet.Add(value); Machine_Enabled.NegativeSet.Add(value);
else else
Enabled.PositiveSet.Add(value); Machine_Enabled.PositiveSet.Add(value);
break; break;
case Field.Machine_CRC: case Field.Machine_CRC:
if (negate || value.Equals("false", StringComparison.OrdinalIgnoreCase)) if (negate || value.Equals("false", StringComparison.OrdinalIgnoreCase))
HasCrc.Neutral = false; Machine_CRC.Neutral = false;
else else
HasCrc.Neutral = true; Machine_CRC.Neutral = true;
break; break;
case Field.Machine_RelatedTo: case Field.Machine_RelatedTo:
if (negate) if (negate)
RelatedTo.NegativeSet.Add(value); Machine_RelatedTo.NegativeSet.Add(value);
else else
RelatedTo.PositiveSet.Add(value); Machine_RelatedTo.PositiveSet.Add(value);
break; break;
#endregion #endregion
@@ -815,23 +831,23 @@ namespace SabreTools.Library.Filtering
case Field.Machine_GenMSXID: case Field.Machine_GenMSXID:
if (negate) if (negate)
GenMSXID.NegativeSet.Add(value); Machine_GenMSXID.NegativeSet.Add(value);
else else
GenMSXID.PositiveSet.Add(value); Machine_GenMSXID.PositiveSet.Add(value);
break; break;
case Field.Machine_System: case Field.Machine_System:
if (negate) if (negate)
System.NegativeSet.Add(value); Machine_System.NegativeSet.Add(value);
else else
System.PositiveSet.Add(value); Machine_System.PositiveSet.Add(value);
break; break;
case Field.Machine_Country: case Field.Machine_Country:
if (negate) if (negate)
Country.NegativeSet.Add(value); Machine_Country.NegativeSet.Add(value);
else else
Country.PositiveSet.Add(value); Machine_Country.PositiveSet.Add(value);
break; break;
#endregion #endregion
@@ -840,9 +856,9 @@ namespace SabreTools.Library.Filtering
case Field.Machine_Supported: case Field.Machine_Supported:
if (negate) if (negate)
SupportedStatus.Negative |= value.AsSupported(); Machine_Supported.Negative |= value.AsSupported();
else else
SupportedStatus.Positive |= value.AsSupported(); Machine_Supported.Positive |= value.AsSupported();
break; break;
#endregion #endregion