protected bool ItemsFilter(object e)
{
if (e is T entity && FilterList.Any(f => f.Key == FilterType) && !string.IsNullOrEmpty(FilterText))
{
var value = entity.GetType().GetProperty(FilterType).GetValue(entity, null);
return(value == null || value.ToString().ToUpper().Contains(FilterText.ToUpper()));
}
public override async Task Initialize()
{
await base.Initialize();
var allClients = await interactorFactory.GetAllClientsInWorkspace(workspaceId).Execute();
Clients = FilterText
.Select(text => text ?? string.Empty)
.Select(text =>
{
var trimmedText = text.Trim();
var selectableViewModels = allClients
.Where(c => c.Name.ContainsIgnoringCase(trimmedText))
.Select(toSelectableViewModel);
var isClientFilterEmpty = string.IsNullOrEmpty(trimmedText);
var suggestCreation = !isClientFilterEmpty
&& allClients.None(c => c.Name == trimmedText)
&& trimmedText.LengthInBytes() <= MaxClientNameLengthInBytes;
if (suggestCreation)
{
var creationSelectableViewModel =
new SelectableClientCreationViewModel(trimmedText);
selectableViewModels = selectableViewModels.Prepend(creationSelectableViewModel);
}
else if (isClientFilterEmpty)
{
selectableViewModels = selectableViewModels.Prepend(noClient);
}
return selectableViewModels;
});
}
private bool AllSnippetsView_Filter(object obj)
{
if (String.IsNullOrEmpty(FilterText))
{
return(true);
}
SnippetViewModel currentSnippet = (SnippetViewModel)obj;
string lowerFilterText = FilterText.ToLower();
if (currentSnippet.Name.ToLower().Contains(lowerFilterText))
{
return(true);
}
if (currentSnippet.Language.Name.ToLower().Contains(lowerFilterText))
{
return(true);
}
if (currentSnippet.Tags.ToList().Where(x => x.Name.ToLower().Contains(lowerFilterText)).Count() > 0)
{
return(true);
}
return(false);
}
private static bool IsFilteredIn(FilterText[] filters, string @namespace)
{
bool isIn = false;
for (int i = 0, max = filters.Length; i < max; ++i)
{
FilterText filter = filters[i];
if (filter.type == Filter.Type.Inclusive)
{
if (isIn == false && @namespace.StartsWith(filter.text) == true)
{
isIn = true;
}
}
else
{
if (@namespace.StartsWith(filter.text) == true)
{
return(false);
}
}
}
return(isIn);
}
/// <summary>
/// Composites the filter.
/// </summary>
/// <param name="obj">The object.</param>
/// <returns></returns>
public bool CompositeFilter(object obj)
{
var item = obj as NursingHome;
if (item == null || string.IsNullOrEmpty(FilterText))
{
return(true);
}
var filterTxt = FilterText.Trim();
if (SelectedFilter == FilterEnumerations[0]) //Nursing Home Name
{
return(!string.IsNullOrEmpty(item.Name) && item.Name.ContainsIgnoreCase(filterTxt));
}
if (SelectedFilter == FilterEnumerations[1]) //City
{
return(!string.IsNullOrEmpty(item.City) && item.City.ContainsIgnoreCase(filterTxt));
}
if (SelectedFilter == FilterEnumerations[2]) //State
{
return(!string.IsNullOrEmpty(item.State) && item.State.ContainsIgnoreCase(filterTxt));
}
return(SelectedFilter != FilterEnumerations[3] || (!string.IsNullOrEmpty(item.ProviderId) && item.ProviderId.ContainsIgnoreCase(filterTxt)));
}
public bool Filter(object modelObject)
{
var objectAsConnectionInfo = modelObject as ConnectionInfo;
if (objectAsConnectionInfo == null)
{
return(false);
}
if (SpecialInclusionList.Contains(objectAsConnectionInfo))
{
return(true);
}
var filterTextLower = FilterText.ToLowerInvariant();
if (objectAsConnectionInfo.Name.ToLowerInvariant().Contains(filterTextLower) ||
objectAsConnectionInfo.Hostname.ToLowerInvariant().Contains(filterTextLower) ||
objectAsConnectionInfo.Description.ToLowerInvariant().Contains(filterTextLower))
{
return(true);
}
return(false);
}
private void FilterDialog_Load(object sender, EventArgs e)
{
Inclusive.Checked = m_filter.Include;
Exclusive.Checked = !m_filter.Include;
FilterText.Text = m_filter.Filter;
if (string.IsNullOrEmpty(m_filter.Globbing))
{
if (string.IsNullOrEmpty(m_filter.Filter))
{
//New filter is default globbing
IsRegExp.Checked = false;
FilterText.Text = "";
}
else
{
IsRegExp.Checked = true;
FilterText.Text = m_filter.Filter;
}
}
else
{
IsRegExp.Checked = false;
FilterText.Text = m_filter.Globbing;
}
try { FilterText.Focus(); }
catch { }
}
private bool BrowseForFile()
{
string[] text = string.IsNullOrEmpty(FilterText) ? new string[0] : FilterText.Split('|');
string[] ext = string.IsNullOrEmpty(FilterExtensions) ? new string[0] : FilterExtensions.Split('|');
if (text.Length != ext.Length)
{
throw new ArgumentException("Filter text length much match filter extension length!");
}
OpenFileDialog ofd = new OpenFileDialog {
FileName = SelectedPath,
Filter = text.Interleave(ext).StringJoin("|")
};
if (DialogResult.OK != ofd.ShowDialog())
{
return(false);
}
using (IDLWrapper wrapper = new IDLWrapper(ofd.FileName)) {
if (wrapper.IDL != null)
{
SelectedIDL = wrapper.IDL;
}
else
{
SelectedPath = wrapper.Path;
}
}
return(true);
}
private List <Photo> findPictureByLocation()
{
List <Photo> locationPhotos = new List <Photo>();
foreach (Album album in Authenticator.LoggedInUser.Albums)
{
foreach (Photo photo in album.Photos)
{
if (photo.Place != null && photo.Place.Name != null && photo.Place.Location != null && photo.Place.Location.City != null)
{
string userPlace = FilterText.ToLower();
string photoPlace = photo.Place.Name.ToLower();
string photoLocation = photo.Place.Location.ToString().ToLower();
string photoLocationCity = photo.Place.Location.City.ToLower();
if (photoPlace.Contains(userPlace) || photoLocation.Contains(userPlace) || photoLocationCity.Contains(userPlace))
{
locationPhotos.Add(photo);
}
}
}
}
return(locationPhotos);
}
private void AssociatedObject_PreviewKeyDown(object sender, KeyEventArgs e)
{
if (!AutoCompletePopup.IsOpen)
{
return;
}
bool close = false;
switch (e.Key)
{
case Key.Escape:
close = true;
break;
case Key.Return:
InsertText();
close = true;
break;
case Key.Up:
AutoCompleteBox.SelectedIndex--;
e.Handled = true;
break;
case Key.Down:
AutoCompleteBox.SelectedIndex++;
e.Handled = true;
break;
case Key.Back:
if (FilterText.Length > 0)
{
FilterText = FilterText.Substring(0, FilterText.Length - 1);
}
else
{
close = true;
}
break;
}
int itemCount = FilteredItems.Count();
if (AutoCompleteBox.SelectedIndex < 0)
{
AutoCompleteBox.SelectedIndex = itemCount - 1;
}
if (AutoCompleteBox.SelectedIndex >= itemCount)
{
AutoCompleteBox.SelectedIndex = 0;
}
if (close)
{
e.Handled = true;
CloseAutoCompleteBox();
}
}
public bool FilerRecords(object o)
{
double res;
bool checkNumeric = double.TryParse(FilterText, out res);
var item = o as OrderInfo;
if (item != null && FilterText.Equals(""))
{
return(true);
}
else
{
if (item != null)
{
if (checkNumeric && !FilterOption.Equals("All Columns") && !FilterOption.Equals("OrderDate"))
{
if (FilterCondition == null || FilterCondition.Equals("Contains") || FilterCondition.Equals("StartsWith") || FilterCondition.Equals("EndsWith"))
{
FilterCondition = "Equals";
}
bool result = MakeNumericFilter(item, FilterOption, FilterCondition);
return(result);
}
else if (FilterOption.Equals("All Columns"))
{
if (item.OrderID.ToString().Contains(FilterText) ||
item.CustomerID.ToLower().Contains(FilterText.ToLower()) ||
item.ProductName.ToLower().Contains(FilterText.ToLower()) || item.Quantity.ToString().Contains(FilterText) ||
item.ShipCountry.ToLower().Contains(FilterText.ToLower()) ||
item.ContactNumber.ToString().Contains(FilterText) ||
item.UnitPrice.ToString().Contains(FilterText) ||
item.OrderDate.ToString().Contains(FilterText))
{
return(true);
}
return(false);
}
else if (FilterOption.Equals("OrderDate"))
{
if (FilterCondition == null || FilterCondition.Equals("Contains") || FilterCondition.Equals("StartsWith") || FilterCondition.Equals("EndsWith"))
{
FilterCondition = "Equals";
}
bool result = MakeDateFilter(item, FilterOption, FilterCondition);
return(result);
}
else
{
if (FilterCondition == null || FilterCondition.Equals("Equals") || FilterCondition.Equals("LessThan") || FilterCondition.Equals("GreaterThan") || FilterCondition.Equals("NotEquals"))
{
FilterCondition = "Contains";
}
bool result = MakeStringFilter(item, FilterOption, FilterCondition);
return(result);
}
}
}
return(false);
}
private void SetAuditGameFilter()
{
ICollectionView cv = CollectionViewSource.GetDefaultView(GamesList);
cv.Filter = o =>
{
var g = o as GameItemViewModel;
if (g.Description != null || g.RomName != null)
{
if (_selectedService.IsMainMenu())
{
return(g.RomName.ToUpper().Contains(FilterText.ToUpper()));
}
else
{
return(g.Description.ToUpper().Contains(FilterText.ToUpper()));
};
}
else
{
return(false);
}
};
}
private void MinistryViewSource_Filter(object sender, FilterEventArgs e)
{
if (string.IsNullOrWhiteSpace(FilterText))
{
//no filter when no search text is entered
e.Accepted = true;
}
else
{
MinistryGridViewModel p = (MinistryGridViewModel)e.Item;
if (!string.IsNullOrEmpty(p.ForeName) && !string.IsNullOrEmpty(p.SureName) &&
p.SureName.ToLower().StartsWith(FilterText.ToLower()) ||
p.ForeName.ToLower().StartsWith(FilterText.ToLower()) ||
p.FullName.ToLower().StartsWith(FilterText.ToLower()) ||
p.FullName2.ToLower().StartsWith(FilterText.ToLower()) ||
p.FullName2.ToLower().Replace(",", "").StartsWith(FilterText.ToLower())
)
{
e.Accepted = true;
return;
}
e.Accepted = false;
}
}
public async Task <bool> CheckAndCommit(char insertedChar)
{
CompletionItem item = CompletionListControl.Items[CompletionListControl.SelectedIndex].item;
List <char> commitCharacters = new List <char>(CompletionList.Rules.DefaultCommitCharacters);
foreach (CharacterSetModificationRule rule in item.Rules.CommitCharacterRules)
{
if (rule.Kind == CharacterSetModificationKind.Add)
{
commitCharacters.AddRange(rule.Characters);
}
else if (rule.Kind == CharacterSetModificationKind.Remove)
{
foreach (char c in rule.Characters)
{
commitCharacters.Remove(c);
}
}
else if (rule.Kind == CharacterSetModificationKind.Replace)
{
commitCharacters = new List <char>(rule.Characters);
}
}
if (commitCharacters.Contains(insertedChar) || insertedChar == '\n' || insertedChar == '\r')
{
await Commit(item);
}
bool tbr = false;
if (insertedChar == '\n' || insertedChar == '\r')
{
EnterKeyRule enterRule = item.Rules.EnterKeyRule;
if (enterRule == EnterKeyRule.Default)
{
enterRule = CompletionList.Rules.DefaultEnterKeyRule;
}
switch (enterRule)
{
case EnterKeyRule.Always:
tbr = false;
break;
case EnterKeyRule.Never:
tbr = true;
break;
case EnterKeyRule.AfterFullyTypedWord:
tbr = FilterText.Equals(item.DisplayText, StringComparison.OrdinalIgnoreCase);
break;
}
}
return(tbr);
}
public void Something()
{
DataCollection.Filter = x =>
{
var person = x as Person;
var filterText = FilterText.ToLower();
return(person.FirstName.ToLower().Contains(filterText) || person.LastName.ToLower().Contains(filterText));
};
}
private ConditionState CheckCondition(object field, IFilterEntity entity)
{
if (entity == null)
{
return(ConditionState.NOT_USED);
}
if (entity is FilterText)
{
FilterText innerEntity = (FilterText)entity;
if (string.IsNullOrEmpty(innerEntity.Condition) || string.IsNullOrEmpty(innerEntity.Value))
{
return(ConditionState.NOT_USED);
}
string innerField = Convert.ToString(field);
if (innerEntity.Condition.Equals("contains"))
{
return(innerField.Contains(innerEntity.Value) ? ConditionState.PASSED : ConditionState.NOT_PASSED);
}
else if (innerEntity.Condition.Equals("equals"))
{
return(innerField.Equals(innerEntity.Value) ? ConditionState.PASSED : ConditionState.NOT_PASSED);
}
else
{
return(ConditionState.NOT_USED);
}
}
else if (entity is FilterDate)
{
FilterDate innerEntity = (FilterDate)entity;
if (innerEntity.From == null || innerEntity.To == null)
{
return(ConditionState.NOT_USED);
}
DateTime innerField = Convert.ToDateTime(field);
DateTime from = DateTime.Parse(innerEntity.From);
DateTime to = DateTime.Parse(innerEntity.To);
int fromResult = DateTime.Compare(from, innerField);
if (fromResult <= 0)
{
int toResult = DateTime.Compare(innerField, to);
if (toResult <= 0)
{
return(ConditionState.PASSED);
}
}
return(ConditionState.NOT_PASSED);
}
else
{
return(ConditionState.NOT_PASSED);
}
}
public bool FilerRecords(object o)
{
double res;
bool checkNumeric = double.TryParse(FilterText, out res);
var item = o as Employee;
if (item != null && FilterText.Equals(""))
{
return(true);
}
else
{
if (item != null)
{
if (checkNumeric && FilterOption.Equals("ContactNumber"))
{
if (FilterCondition == null || FilterCondition.Equals("Equals") || FilterCondition.Equals("LessThan") || FilterCondition.Equals("GreaterThan") || FilterCondition.Equals("NotEquals"))
{
FilterCondition = "Contains";
}
bool result = MakeStringFilter(item, FilterOption, FilterCondition);
return(result);
}
else if (checkNumeric && !FilterOption.Equals("AllColumns"))
{
if (FilterCondition == null || FilterCondition.Equals("Contains") || FilterCondition.Equals("StartsWith") || FilterCondition.Equals("EndsWith"))
{
FilterCondition = "Equals";
}
bool result = MakeNumericFilter(item, FilterOption, FilterCondition);
return(result);
}
else if (FilterOption.Equals("AllColumns"))
{
if (item.FirstName.ToLower().Contains(FilterText.ToLower()) ||
item.LastName.ToLower().Contains(FilterText.ToLower()) || item.City.ToLower().Contains(FilterText.ToLower()) ||
item.Salary.ToString().ToLower().Contains(FilterText.ToLower()) || item.EmployeeID.ToString().ToLower().Contains(FilterText.ToLower()) ||
item.ContactNumber.ToLower().Contains(FilterText.ToLower()))
{
return(true);
}
return(false);
}
else
{
if (FilterCondition == null || FilterCondition.Equals("Equals") || FilterCondition.Equals("LessThan") || FilterCondition.Equals("GreaterThan") || FilterCondition.Equals("NotEquals"))
{
FilterCondition = "Contains";
}
bool result = MakeStringFilter(item, FilterOption, FilterCondition);
return(result);
}
}
}
return(false);
}
public FilterControl()
{
InitializeComponent();
var height = Math.Max(FilterText.Height, FilterText.GetPreferredSize(new Size(999, 999)).Height);
MinimumSize = new Size(0, height);
MaximumSize = new Size(999999, height);
Height = height;
}
public override int GetHashCode()
{
unchecked
{
var hashCode = Id ?? 0;
hashCode = (hashCode * 397) ^ FilterText?.GetHashCode() ?? 0;
hashCode = (hashCode * 397) ^ Name?.GetHashCode() ?? 0;
return(hashCode);
}
}
private void FilterAnimeList()
{
AnimeList.Clear();
MainAnimeList.ToList().ForEach(x =>
{
if (x.Title.ToLower().Contains(FilterText.ToLower()))
{
AnimeList.Add(x);
}
});
}
public override Task Initialize(SelectTagsParameter parameter)
{
workspaceId = parameter.WorkspaceId;
defaultResult = parameter.TagIds;
selectedTagIds.AddRange(parameter.TagIds);
creationEnabled = parameter.CreationEnabled;
var filteredTags = FilterText
.StartWith(string.Empty)
.Select(text => text?.Trim() ?? string.Empty)
.SelectMany(getSuggestions)
.Select(selectableTagNameViewModel)
.ShareReplay();
Tags = filteredTags
.AsDriver(ImmutableList <SelectableTagBaseViewModel> .Empty, schedulerProvider);
IsEmpty = filteredTags
.Select(tags => tags.Any())
.Invert()
.DistinctUntilChanged()
.AsDriver(schedulerProvider);
return(base.Initialize(parameter));
IImmutableList <SelectableTagBaseViewModel> selectableTagNameViewModel((string, IEnumerable <AutocompleteSuggestion>) pair)
{
var queryText = pair.Item1;
var suggestions = pair.Item2;
var tagSuggestionInWorkspace = suggestions
.Cast <TagSuggestion>()
.Where(s => s.WorkspaceId == workspaceId);
var suggestCreation = creationEnabled && !string.IsNullOrEmpty(queryText) &&
tagSuggestionInWorkspace.None(tag
=> tag.Name.IsSameCaseInsensitiveTrimedTextAs(queryText)) &&
queryText.IsAllowedTagByteSize();
var selectableViewModels = tagSuggestionInWorkspace
.OrderByDescending(tag => defaultResult.Contains(tag.TagId))
.ThenBy(tag => tag.Name)
.Select(toSelectableTagViewModel);
if (suggestCreation)
{
return(selectableViewModels
.Prepend(new SelectableTagCreationViewModel(queryText, workspaceId))
.ToImmutableList());
}
return(selectableViewModels.ToImmutableList());
}
}
public MainViewModel()
{
WinConsole.Initialize();
ExitCommand = new Command(Exit);
ConsoleCommand = new Command(p => WinConsole.Visible = !WinConsole.Visible);
AddCommand = new Command(Add);
DeleteCommand = new Command(Delete)
{
CanExecuteFunction = p => CanDelete
};
EditCommand = new Command(Edit)
{
CanExecuteFunction = p => CanEdit
};
AboutCommand = new Command(ShowAboutDialog);
LoadCommand = new Command(Load);
SaveCommand = new Command(Save);
ClearFilterCommand = new Command(() => FilterText = "");
CalcCommand = new Command(Calculate);
OpenFileCommand = new Command
{
CanExecuteFunction = p => true,
ExecuteFunction = p => OpenFile()
};
People = new ObservableCollection <Person>();
Config = new Configurator();
PeopleView = CollectionViewSource.GetDefaultView(People);
PeopleView.Filter = obj =>
{
if (FilterText.IsEmpty())
{
return(true);
}
var p = obj as Person;
return(p != null && p.FullName.IndexOf(FilterText, StringComparison.CurrentCultureIgnoreCase) >= 0);
};
Initialize();
}
private void FilterData()
{
if (!string.IsNullOrEmpty(FilterText))
{
Icons = IconList.Where(a => (a.Name.ToString().ToLower().Contains(FilterText.ToLower())));
//Icons = Icons.Where(a => (a.Name.ToString().Contains(FilterText)) || (a.Description.ToString().Contains(FilterText))).ToList();
}
else
{
Icons = IconList;
}
}
void Filter(object sender, FilterEventArgs e)
{
if (string.IsNullOrEmpty(FilterText))
{
e.Accepted = true;
return;
}
var entry = e.Item as BarEntry;
e.Accepted = entry.FileNameWithRoot.ToLower().Contains(FilterText.ToLower());
}
protected override IAsyncResult BeginExecute(AsyncCodeActivityContext context, AsyncCallback callback, object state)
{
try
{
m_Delegate = new runDelegate(Run);
string filterText = FilterText.Get(context);
TreeScope treeScope;
if (Scope == ScopeOption.Children)
{
treeScope = TreeScope.Children;
}
else if (Scope == ScopeOption.Descendants)
{
treeScope = TreeScope.Descendants;
}
else
{
treeScope = TreeScope.Subtree;
}
UiElement element = null;
var selStr = Selector.Get(context);
element = Common.GetValueOrDefault(context, this.Element, null);
if (element == null && selStr != null)
{
element = UiElement.FromSelector(selStr);
}
else
{
PropertyDescriptor property = context.DataContext.GetProperties()[EleScope.GetEleScope];
element = property.GetValue(context.DataContext) as UiElement;
}
List <UiElement> uiList = new List <UiElement>();
uiList = element.FindAllByFilter(treeScope, TrueCondition.Default, filterText);
UiList.Set(context, uiList);
return(m_Delegate.BeginInvoke(callback, state));
}
catch (Exception e)
{
SharedObject.Instance.Output(SharedObject.enOutputType.Error, "获取子节点元素失败", e.Message);
if (ContinueOnError.Get(context))
{
return(m_Delegate.BeginInvoke(callback, state));
}
else
{
throw e;
}
}
}
public void FilterBackground()
{
var filteredRows = new List <RowItem>();
var normalizedFilterText = MatchCase ? FilterText : FilterText.ToLower();
// toString on an enum is incredibly slow, so we cache the results in
// in a dictionary.
var toStringCaches = new Dictionary <object, string> [_properties.Length];
for (int i = 0; i < _properties.Length; i++)
{
if (_properties[i].PropertyType.IsEnum)
{
toStringCaches[i] = new Dictionary <object, string>();
}
}
foreach (var row in _rows)
{
CheckDisposed();
for (int i = 0; i < _properties.Length; i++)
{
var property = _properties[i];
var value = property.GetValue(row);
if (value == null)
{
continue;
}
var cache = toStringCaches[i];
string strValue;
if (cache == null)
{
strValue = value.ToString();
}
else
{
if (!cache.TryGetValue(value, out strValue))
{
strValue = value.ToString();
cache.Add(value, strValue);
}
}
if (!MatchCase)
{
strValue = strValue.ToLower();
}
if (strValue.IndexOf(normalizedFilterText) >= 0)
{
filteredRows.Add(row);
break;
}
}
}
FilteredRows = filteredRows.ToArray();
}
private bool HasCustomerForFilteredText(ICustomer c)
{
var filterText = FilterText.ToUpper();
var isInFilteredText1 = c.Firstname.ToUpper().Contains(filterText) || c.Lastname.ToUpper().Contains(filterText) ||
c.CustomerNumber.ToUpper().Contains(filterText);
var isInFilteredText2 = !string.IsNullOrEmpty(c.Email) && c.Email.ToUpper().Contains(filterText);
var isInFilteredText3 = !string.IsNullOrEmpty(c.Phone) && c.Phone.Contains(filterText);
var isInFilteredText4 = !string.IsNullOrEmpty(c.Password) && c.Password.ToUpper().Contains(filterText);
var isInFilteredText5 = !string.IsNullOrEmpty(c.Website) && c.Website.ToUpper().Contains(filterText);
return(isInFilteredText1 || isInFilteredText2 || isInFilteredText3 || isInFilteredText4 || isInFilteredText5);
}
public override async Task Initialize()
{
await base.Initialize();
var allClients = await interactorFactory
.GetAllClientsInWorkspace(workspaceId)
.Execute();
Clients = FilterText
.Select(text => text?.Trim() ?? string.Empty)
.DistinctUntilChanged()
.Select(trimmedText => filterClientsByText(trimmedText, allClients))
.AsDriver(Enumerable.Empty <SelectableClientBaseViewModel>(), schedulerProvider);
}
private bool FilterRow(object param)
{
if (string.IsNullOrEmpty(FilterText))
{
return(true);
}
var itemViewModel = param as SecurityDataViewModel;
if (itemViewModel == null)
{
return(false);
}
return(itemViewModel.Security.Name.ToLower().Contains(FilterText.Trim().ToLower()));
}
/// <summary>
/// Filters songs using FilterText property. Does NOT sort results.
/// </summary>
/// <param name="songTitles">song list to apply filter to</param>
/// <returns>filtered song list (of type MultiLineTextEdit)</returns>
private List <string> FilterSongsByTitle(List <string> songTitles)
{
if (string.IsNullOrEmpty(FilterText))
{
return(songTitles);
}
var _filterText = FilterText;
var filteredSongTitleList = (from songTitle in songTitles
where songTitle.ToLower().Contains(FilterText.ToLower())
select songTitle).ToList();
return(filteredSongTitleList);
}
