private IEnumerable <IResult> LoadUsers()
{
yield return(new SingleResult
{
Action = () =>
{
LoadText = "Loading...";
TotalUsedSpace = 0;
}
});
var loadResult = new LoadResult {
Filer = CreateFilter(PageSize)
};
yield return(loadResult);
Users.Clear();
long usedSpace = 0;
foreach (AdminUserDTO adminUserDto in loadResult.Users)
{
usedSpace += adminUserDto.DatabaseSize ?? 0;
Users.Add(MapToViewModel(adminUserDto));
}
TotalUsedSpace = usedSpace;
LoadText = "Load";
}
public void Logout()
{
_dataService.Disconnect();
CurrentUserName = _dataService.UserName;
_week.Clear();
NotifyVisibilityChanged();
}
private void SynchronizeSelectionCollections <TSource, TTarget>(IObservableCollection <TTarget> collection, Func <TSource, TTarget> getItem, NotifyCollectionChangedEventArgs e)
{
if (synchronizingSelection)
{
return;
}
synchronizingSelection = true;
if (e.NewItems != null)
{
foreach (TSource newItem in e.NewItems)
{
var targetItem = getItem(newItem);
collection.Add(targetItem);
}
}
if (e.OldItems != null)
{
foreach (TSource oldItem in e.OldItems)
{
var targetItem = getItem(oldItem);
collection.Remove(targetItem);
}
}
if (e.Action == NotifyCollectionChangedAction.Reset)
{
collection.Clear();
}
synchronizingSelection = false;
}
public static void Replace <T>(this IObservableCollection <T> collection, IEnumerable <T> items)
{
collection.IsNotifying = false;
collection.Clear();
collection.AddRange(items);
collection.IsNotifying = true;
collection.Refresh();
}
public bool ReceiveWeakEvent(Type managerType, object sender, EventArgs e)
{
if (managerType == typeof(CollectionChangedEventManager))
{
NotifyCollectionChangedEventArgs arg = e as NotifyCollectionChangedEventArgs;
if (arg != null)
{
switch (arg.Action)
{
case NotifyCollectionChangedAction.Add:
if (arg.NewItems != null)
{
for (int itemIndex = 0; itemIndex < arg.NewItems.Count; itemIndex++)
{
_syncCollection.Insert(arg.NewStartingIndex +
itemIndex, _create(arg.NewItems[itemIndex] as T));
}
break;
}
break;
case NotifyCollectionChangedAction.Move:
_syncCollection.RemoveAt(arg.OldStartingIndex);
_syncCollection.Insert(arg.NewStartingIndex, _create(arg.NewItems[0] as T));
break;
case NotifyCollectionChangedAction.Remove:
if (arg.OldItems != null && _syncCollection.Count > 0)
{
for (int itemIndex = 0; itemIndex < arg.OldItems.Count; itemIndex++)
{
_syncCollection.RemoveAt(arg.OldStartingIndex);
}
}
break;
case NotifyCollectionChangedAction.Replace:
if (arg.NewItems == null)
{
for (int itemIndex = 0; itemIndex < arg.NewItems.Count; itemIndex++)
{
_syncCollection[arg.NewStartingIndex + itemIndex] = _create(arg.NewItems[itemIndex] as T);
}
}
break;
case NotifyCollectionChangedAction.Reset:
_syncCollection.Clear();
break;
default:
break;
}
}
return(true);
}
return(false);
}
private void RefreshServersFromPhysicalModel()
{
var groupedServers = physicalModel.Endpoints.GroupBy(x => x.ServerName);
servers.Clear();
foreach (var keys in groupedServers)
{
servers.Add(new Server {
Name = keys.Key
});
}
}
public void Init()
{
CodeTemplate[] templates = new CodeTemplate[0];
_provider.ExecuteScopedWork(provider =>
{
IDataContract contract = provider.GetRequiredService <IDataContract>();
templates = contract.CodeTemplates.OrderBy(m => !m.IsSystem).ThenBy(m => m.Order).ToArray();
});
Templates.Clear();
foreach (CodeTemplate template in templates)
{
TemplateViewModel model = _provider.GetRequiredService <TemplateViewModel>();
model = template.MapTo(model);
Templates.Add(model);
}
}
/// <summary>
/// Função chamada quando a tela é exibida
/// </summary>
protected override void OnActivate()
{
_manipulacoes.Clear();
// Recupera uma referência do banco
using (var db = new DataBase.ManipulaImagemContext())
{
// Carrega as manipulações cadastradas
_manipulacoes.AddRange(
db.Manipulacoes.ToArray().Select(m =>
{
var i = IoC.Get <ManipulacaoItemViewModel>();
i.Manipulacao = m;
i.Excluido += (s, e) => _manipulacoes.Remove(i);
return(i);
}));
}
}
private static void ReorderRecentFiles(IObservableCollection <RecentFileInfo> target)
{
if (target == null)
{
return;
}
var orderedItem = new List <RecentFileInfo>();
orderedItem.AddRange(target.Where(p => p.FixedAt.HasValue).OrderByDescending(p => p.FixedAt));
orderedItem.AddRange(target.Where(p => !p.FixedAt.HasValue).OrderByDescending(p => p.LastOpenedAt));
target.IsNotifying = false;
target.Clear();
target.IsNotifying = true;
target.AddRange(orderedItem);
}
/// <summary>
/// Download all transactions for specific account of the specific user.
/// </summary>
/// <returns>Operation result.</returns>
public IEnumerable <IResult> DownloadAllTransactions()
{
yield return(Show.Busy(new BusyScreen {
Message = "Loading..."
}));
var request = new GetAllTransactionsResult(userId, CurrentAccount.Id);
yield return(request);
TransactionRecords.Clear();
TransactionRecords.AddRange(request.TransactionRecords);
if (Reloaded != null)
{
Reloaded(this, EventArgs.Empty);
}
yield return(Show.NotBusy());
}
private void ReloadApproaches()
{
this.SelectedApproache = null;
approachesCache.Clear();
IReadOnlyList <ApproachSummaryDto> dtos = this.approachService.GetApproaches();
foreach (ApproachSummaryDto dto in dtos)
{
IApproachDetailsViewModel detailsViewModel = this.detailsViewModelFactory.Invoke();
detailsViewModel.Load(dto.Id, dto.Name, dto.Criteria);
approachesCache.Add(detailsViewModel);
}
this.NotifyOfPropertyChange(() => this.Approaches);
this.NotifyOfPropertyChange(() => this.SelectedApproache);
this.NotifyOfPropertyChange(() => this.CanCreate);
this.NotifyOfPropertyChange(() => this.CanDelete);
this.NotifyOfPropertyChange(() => this.CanEdit);
this.NotifyOfPropertyChange(() => this.CanOpen);
}
public static void BuildPlugins(IEnumerable <Lazy <IDPlugin, IPluginMetaData> > _plugins,
IObservableCollection <IDPlugin> items, string id)
{
items.Clear();
var plugins = _plugins.Where(x => x.Metadata.ParentId == id)
.OrderBy(x => x.Metadata.Priority);
foreach (var v in plugins)
{
var screen = v.Value;
if (screen is IDPlugin iScreen)
{
iScreen.DisplayName = v.Metadata.Name.Translate();
iScreen.Panel.Icon = v.Metadata.Icon;
iScreen.Panel.Id = v.Metadata.Id;
}
items.Add(v.Value);
}
}
public void ClearConsole()
{
Console.Clear();
}
private void TestEvents(IObservableCollection<string> instance)
{
var stringToAdd = "Adam is awesome";
var addingCallCount = 0;
var addedCallCount = 0;
var removingCallCount = 0;
var removedCallCount = 0;
var clearingCallCount = 0;
var clearedCallCount = 0;
EventHandler<ObservableCollectionChangingEventArgs<string>> cancelAddHandler = (sender, eventArgs) =>
{
addingCallCount++;
eventArgs.Items.Should().Contain(stringToAdd);
eventArgs.Items.Count().Should().Be(1);
eventArgs.ChangeType.Should().Be(ObservableCollectionChangeTypes.ItemsAdded);
eventArgs.CancelOperation.Should().BeFalse();
eventArgs.CancelOperation = true;
var collection = sender as IEnumerable<string>;
collection.Should().NotBeNull();
collection.Should().NotContain(x => eventArgs.Items.Contains(x));
};
EventHandler<ObservableCollectionChangingEventArgs<string>> allowAddHandler = (sender, eventArgs) =>
{
addingCallCount++;
eventArgs.Items.Should().Contain(stringToAdd);
eventArgs.Items.Count().Should().Be(1);
eventArgs.ChangeType.Should().Be(ObservableCollectionChangeTypes.ItemsAdded);
eventArgs.CancelOperation.Should().BeFalse();
var collection = sender as IEnumerable<string>;
collection.Should().NotBeNull();
collection.Should().NotContain(x => eventArgs.Items.Contains(x));
};
EventHandler<ObservableCollectionChangedEventArgs<string>> addChangedHandler = (sender, eventArgs) =>
{
addedCallCount++;
eventArgs.Items.Should().Contain(stringToAdd);
eventArgs.Items.Count().Should().Be(1);
eventArgs.ChangeType.Should().Be(ObservableCollectionChangeTypes.ItemsAdded);
var collection = sender as IEnumerable<string>;
collection.Should().NotBeNull();
collection.Should().Contain(x => eventArgs.Items.Contains(x));
};
EventHandler<ObservableCollectionChangingEventArgs<string>> cancelRemoveHandler = (sender, eventArgs) =>
{
removingCallCount++;
eventArgs.Items.Should().Contain(stringToAdd);
eventArgs.Items.Count().Should().Be(1);
eventArgs.ChangeType.Should().Be(ObservableCollectionChangeTypes.ItemsRemoved);
eventArgs.CancelOperation.Should().BeFalse();
eventArgs.CancelOperation = true;
var collection = sender as IEnumerable<string>;
collection.Should().NotBeNull();
collection.Should().Contain(x => eventArgs.Items.Contains(x));
};
EventHandler<ObservableCollectionChangingEventArgs<string>> allowRemoveHandler = (sender, eventArgs) =>
{
removingCallCount++;
eventArgs.Items.Should().Contain(stringToAdd);
eventArgs.Items.Count().Should().Be(1);
eventArgs.ChangeType.Should().Be(ObservableCollectionChangeTypes.ItemsRemoved);
eventArgs.CancelOperation.Should().BeFalse();
var collection = sender as IEnumerable<string>;
collection.Should().NotBeNull();
collection.Should().Contain(x => eventArgs.Items.Contains(x));
};
EventHandler<ObservableCollectionChangedEventArgs<string>> removeChangedHandler = (sender, eventArgs) =>
{
removedCallCount++;
eventArgs.Items.Should().Contain(stringToAdd);
eventArgs.Items.Count().Should().Be(1);
eventArgs.ChangeType.Should().Be(ObservableCollectionChangeTypes.ItemsRemoved);
var collection = sender as IEnumerable<string>;
collection.Should().NotBeNull();
collection.Should().NotContain(x => eventArgs.Items.Contains(x));
};
EventHandler<ObservableCollectionChangingEventArgs<string>> cancelClearHandler = (sender, eventArgs) =>
{
clearingCallCount++;
eventArgs.Items.Count().Should().Be(2);
eventArgs.ChangeType.Should().Be(ObservableCollectionChangeTypes.ItemsRemoved);
eventArgs.CancelOperation.Should().BeFalse();
eventArgs.CancelOperation = true;
var collection = sender as IEnumerable<string>;
collection.Should().NotBeNull();
collection.Should().Contain(x => eventArgs.Items.Contains(x));
};
EventHandler<ObservableCollectionChangingEventArgs<string>> allowClearHandler = (sender, eventArgs) =>
{
clearingCallCount++;
eventArgs.Items.Count().Should().Be(2);
eventArgs.ChangeType.Should().Be(ObservableCollectionChangeTypes.ItemsRemoved);
eventArgs.CancelOperation.Should().BeFalse();
var collection = sender as IEnumerable<string>;
collection.Should().NotBeNull();
collection.Should().Contain(x => eventArgs.Items.Contains(x));
};
EventHandler<ObservableCollectionChangedEventArgs<string>> clearChangedHandler = (sender, eventArgs) =>
{
clearedCallCount++;
eventArgs.Items.Count().Should().Be(2);
eventArgs.ChangeType.Should().Be(ObservableCollectionChangeTypes.ItemsRemoved);
var collection = sender as IEnumerable<string>;
collection.Should().NotBeNull();
collection.Should().NotContain(x => eventArgs.Items.Contains(x));
};
// try to add with cancelAddHandler first, then with allowAddHandler, then remove with cancelRemoveHandler, then allowRemoveHandler
instance.Clear();
instance.Should().BeEmpty();
instance.Changing += cancelAddHandler;
instance.Changed += addChangedHandler;
instance.Add(null);
instance.Should().BeEmpty();
addingCallCount.Should().Be(0);
addedCallCount.Should().Be(0);
instance.Add(stringToAdd);
instance.Should().BeEmpty();
addingCallCount.Should().Be(1);
addedCallCount.Should().Be(0);
instance.Changing -= cancelAddHandler;
instance.Changing += allowAddHandler;
instance.Add(stringToAdd);
instance.Should().Contain(stringToAdd);
instance.Count.Should().Be(1);
addingCallCount.Should().Be(2);
addedCallCount.Should().Be(1);
instance.Changing -= allowAddHandler;
instance.Changed -= addChangedHandler;
instance.Changing += cancelRemoveHandler;
instance.Changed += removeChangedHandler;
instance.Remove(null);
instance.Count.Should().Be(1);
removingCallCount.Should().Be(0);
removedCallCount.Should().Be(0);
instance.Remove(stringToAdd);
instance.Should().Contain(stringToAdd);
instance.Count.Should().Be(1);
removingCallCount.Should().Be(1);
removedCallCount.Should().Be(0);
instance.Changing -= cancelRemoveHandler;
instance.Changing += allowRemoveHandler;
instance.Remove(stringToAdd);
instance.Should().BeEmpty();
removingCallCount.Should().Be(2);
removedCallCount.Should().Be(1);
instance.Changing -= allowRemoveHandler;
instance.Changed -= removeChangedHandler;
instance.Changing += cancelClearHandler;
instance.Changed += clearChangedHandler;
instance.Clear();
clearingCallCount.Should().Be(0);
clearedCallCount.Should().Be(0);
instance.Changing -= cancelClearHandler;
instance.Changed -= clearChangedHandler;
instance.Add("a");
instance.Add("b");
instance.Count.Should().Be(2);
instance.Changing += cancelClearHandler;
instance.Changed += clearChangedHandler;
instance.Clear();
instance.Count.Should().Be(2);
clearingCallCount.Should().Be(1);
clearedCallCount.Should().Be(0);
instance.Changing -= cancelClearHandler;
instance.Changing += allowClearHandler;
instance.Clear();
instance.Should().BeEmpty();
clearingCallCount.Should().Be(2);
clearedCallCount.Should().Be(1);
instance.Changing -= allowClearHandler;
instance.Changed -= clearChangedHandler;
}
public void Clear() => _collectionImplementation.Clear();
void Reset()
{
Datas.Clear();
SelectedData = null;
}
/// <summary>
/// Limpa a coleção.
/// </summary>
public void Clear()
{
_source.Clear();
}