private void CaseInfoChangePriority(CasePropertySet item, bool moveUp)
{
var siblingItem = moveUp ? Items.FirstOrDefault(
x => x.Priority <= item.Priority && x.CasePropertySetId != item.CasePropertySetId)
: Items.FirstOrDefault(x => x.Priority > item.Priority);
if (siblingItem != null)
{
var tmpPriority = item.Priority;
if (item.Priority == siblingItem.Priority)
{
item.Priority = siblingItem.Priority + (moveUp ? 1 : -1);
}
else
{
item.Priority = siblingItem.Priority;
}
siblingItem.Priority = tmpPriority;
using (var repository = _repositoryFactory.GetRepositoryInstance())
{
var it1 = repository.CasePropertySets.Where(x => x.CasePropertySetId == item.CasePropertySetId).SingleOrDefault();
var it2 =
repository.CasePropertySets.Where(x => x.CasePropertySetId == siblingItem.CasePropertySetId).SingleOrDefault();
it1.Priority = item.Priority;
it2.Priority = siblingItem.Priority;
repository.UnitOfWork.Commit();
}
OnUIThread(() => ItemsView.Refresh());
ItemMoveUpCommand.RaiseCanExecuteChanged();
ItemMoveDownCommand.RaiseCanExecuteChanged();
}
}
public override void OnNavigatedTo(INavigationParameters parameters)
{
base.OnNavigatedTo(parameters);
SelectedSortOptionItem = QueuePlaylist.DefaultSortOption;
Observable.Merge(
IsEnableGroupingByTitleSimulality.ToUnit(),
this.ObserveProperty(x => x.SelectedSortOptionItem, isPushCurrentValueAtFirst: false).ToUnit()
)
.Subscribe(sort => ResetList())
.AddTo(_navigationDisposables);
_messenger.Register <PlaylistItemRemovedMessage, PlaylistId>(this, QueuePlaylist.Id, (r, m) =>
{
foreach (var item in m.Value.RemovedItems)
{
var remove = ItemsView.Cast <IVideoContent>().FirstOrDefault(x => x.VideoId == item.VideoId);
ItemsView.Remove(remove);
}
});
_messenger.Register <PlaylistItemAddedMessage, PlaylistId>(this, QueuePlaylist.Id, (r, m) =>
{
ItemsView.Clear();
ItemsView.Refresh();
});
}
/// <summary>
/// Reacts on any property change of any item in <see cref="Items" />.
/// </summary>
/// <param name="sender">The item that has a changed property.</param>
/// <param name="e">The event args.</param>
public virtual void OnItemPropertyChanged(object sender, PropertyChangedEventArgs e)
{
if (RefreshViewOnItemChange)
{
ItemsView.Refresh();
}
}
public void ToggleAlertSender(object sender)
{
if (sender == null)
{
return;
}
try
{
var imageAwesome = (ImageAwesome)sender;
var item = (Item)imageAwesome.DataContext;
if (item.AlertModeMinSellPriceIsUndercutPrice <= 0)
{
return;
}
item.IsAlertActive = AlertManager.ToggleAlert(ref item);
ItemsView.Refresh();
}
catch (Exception e)
{
Log.Error(nameof(ToggleAlertSender), e);
}
}
private void MoveToPage(int pageIndex)
{
if (Pages.Count <= 0)
{
return;
}
if (Pages.Count == pageIndex)
{
ExtendedNextCommand.Execute(ExtendedNextCommandParams);
return;
}
if (PageIndex >= 0)
{
Pages.ElementAt(PageIndex).IsSelected = false;
}
PageIndex = pageIndex;
if (PageIndex >= 0)
{
Pages.ElementAt(PageIndex).IsSelected = true;
}
CommandManager.InvalidateRequerySuggested();
ItemsView.Refresh();
PagesView.Refresh();
CalculateWidths();
}
private void MoveToPage(int pageIndex)
{
CurrentPage = pageIndex;
CommandManager.InvalidateRequerySuggested();
ItemsView.Refresh();
}
public void RefreshIndices()
{
foreach (var item in Items)
{
item.Update(tasksModel.Get(item.Id));
}
ItemsView.Refresh();
}
void HandleTaskUpdated(object sender, EntityEventArgs <Task> e)
{
ITaskListItemViewModel item = Items.FirstOrDefault(i => i.Id == e.Entity.Id);
if (item != null)
{
Task task = tasksModel.Get(e.Entity.Id);
item.Update(task);
}
ItemsView.Refresh();
}
public RepositorySelectViewModel(IRepositoryCloneService service)
{
Guard.ArgumentNotNull(service, nameof(service));
this.service = service;
repository = this.WhenAnyValue(x => x.SelectedItem)
.Select(CreateRepository)
.ToProperty(this, x => x.Repository);
this.WhenAnyValue(x => x.Filter).Subscribe(_ => ItemsView?.Refresh());
}
private void ExecuteFilter()
{
Regex r = null;
if (string.IsNullOrWhiteSpace(InputToFilter))
{
ItemsView.Filter = null;
ItemsView.Refresh();
SelectFirst();
return;
}
// 一旦保留
//using (var m = Migemo.GetDefault())
//{
// Debug.WriteLine(m.Query(InputToFilter));
// try
// {
// r = m.GetRegex(InputToFilter);
// }
// catch (Exception e)
// {
// Debug.WriteLine(e.Message);
// r = null;
// }
//}
var comparer = StringComparer.Create(CultureInfo.CurrentCulture, true);
Predicate <object> filter;
if (r == null)
{
filter = x =>
{
var s = x as SheetHandler;
var source = s?.Header ?? "";
const CompareOptions options = CompareOptions.IgnoreCase | CompareOptions.IgnoreKanaType | CompareOptions.IgnoreNonSpace | CompareOptions.IgnoreSymbols | CompareOptions.IgnoreWidth;
return(CultureInfo.CurrentCulture.CompareInfo.IndexOf(source, InputToFilter, options) >= 0);
};
}
else
{
filter = x =>
{
var s = x as SheetHandler;
return(r.IsMatch(s?.Header ?? ""));
};
}
ItemsView.Filter = filter;
SelectFirst();
}
/// <summary>
/// Adds a bunch of <paramref name="items" /> to the internal data collection.
/// </summary>
/// <remarks>
/// Calls <see cref="Add" /> for each item internally.
/// </remarks>
/// <param name="items">The items to add.</param>
public void AddRange(IEnumerable <TItem> items)
{
Items.CollectionChanged -= OnItemsCollectionChanged;
foreach (var item in items)
{
Add(item);
}
Items.CollectionChanged += OnItemsCollectionChanged;
if (_isInPreview)
{
ItemsView.Refresh();
}
_fullView.Refresh();
}
private void LoadData()
{
Items.Clear();
var service = Proxy.CreateProxy();
this.ShowTSL = string.Compare(service.GetParameterValue(eGlobalParameter.ShowTSL), "true", true) == 0;
OnPropertyChanged("ShowTSL");
var contactList = service.GetAllContacts();
foreach (var item in contactList)
{
Items.Add(new ContactItemViewModel(item, this.Items.Select(it => it.Phone)));
}
ItemsView.Refresh();
}
public override void RaiseCanExecuteChanged()
{
base.RaiseCanExecuteChanged();
if (ItemMoveUpCommand != null)
{
ItemMoveUpCommand.RaiseCanExecuteChanged();
}
if (ItemMoveDownCommand != null)
{
ItemMoveDownCommand.RaiseCanExecuteChanged();
}
if (ItemsView != null)
{
ItemsView.Refresh();
}
}
public WorldGridsViewModel()
{
_items = GenerateData();
ItemsView.Filter = new Predicate <object>(o => Filter(o as RegionGridsViewModel));
ItemsView.Refresh();
/*
* foreach (var model in _items)
* {
* model.PropertyChanged += (sender, args) =>
* {
* if (args.PropertyName == nameof(RegionGridsViewModel.IsSelected))
* OnPropertyChanged(nameof(IsAllItemsSelected));
* };
* }
*/
}
private void OnManufaturerFilter(MenuItem obj)
{
if ((string)obj.Header == TextAll)
{
((MenuItem)obj.Parent).Items.Cast <MenuItem>().Where(e => e.IsChecked && (string)e.Header != TextAll).
Foreach(e => e.IsChecked = false);
_manufactureFilter = null;
}
else
{
var items = ((MenuItem)obj.Parent).Items.Cast <MenuItem>().ToArray();
items.FirstOrDefault(e => (string)e.Header == TextAll).IsChecked = false;
_manufactureFilter = items.Where(e => e.IsChecked).Select(e => (string)e.Header).
ToArray();
}
ItemsView.Refresh();
}
private void OnRadiusesFilter(MenuItem obj)
{
var header = obj.Header as string;
if (header == TextAll)
{
((MenuItem)obj.Parent).Items.Cast <MenuItem>().Where(e => e.IsChecked && e.Header is int).
Foreach(e => e.IsChecked = false);
_radiusFilter = null;
}
else
{
var items = ((MenuItem)obj.Parent).Items.Cast <MenuItem>().ToArray();
items.FirstOrDefault(e => e.Header is string).IsChecked = false;
_radiusFilter = items.Where(e => e.IsChecked && e.Header is int).Select(e => (int)e.Header).
ToArray();
}
ItemsView.Refresh();
}
void FilterChanged()
{
if (!string.IsNullOrWhiteSpace(SearchQuery))
{
numberFilter = 0;
int.TryParse(SearchQuery.Substring(SearchQuery.StartsWith('#') ? 1 : 0), out numberFilter);
if (numberFilter == 0)
{
stringFilter = SearchQuery.ToUpperInvariant();
}
}
else
{
stringFilter = null;
numberFilter = 0;
}
ItemsView?.Refresh();
}
public RepositorySelectViewModel(IRepositoryCloneService service, IGitHubContextService gitHubContextService)
{
Guard.ArgumentNotNull(service, nameof(service));
Guard.ArgumentNotNull(service, nameof(gitHubContextService));
this.service = service;
this.gitHubContextService = gitHubContextService;
var selectedRepository = this.WhenAnyValue(x => x.SelectedItem)
.Select(CreateRepository);
var filterRepository = this.WhenAnyValue(x => x.Filter)
.Select(f => gitHubContextService.FindContextFromUrl(f))
.Select(CreateRepository);
repository = selectedRepository
.Merge(filterRepository)
.ToProperty(this, x => x.Repository);
this.WhenAnyValue(x => x.Filter).Subscribe(_ => ItemsView?.Refresh());
}
//------------------------------------------------------------------------------------
/// <summary>
/// RefreshView command
/// </summary>
//------------------------------------------------------------------------------------
public virtual void RefreshView()
{
ItemsView.Refresh();
}
//------------------------------------------------------------------------------------
/// <summary>
/// FilterSelectionsChanged command
/// </summary>
//------------------------------------------------------------------------------------
public virtual void FilterSelectionsChanged()
{
ItemsView.Refresh();
}
