private async Task PopulateMapAsync() { var idsAsString = NavigationNearbyStationIdList.Split(new char[] { ',' }); var ids = idsAsString.Select(Int32.Parse).ToList(); var hst = await _dataService.GetHaltestellenAsync(ids); var mapPins = new List<MapHaltestelleModel>(); foreach (var h in hst) { try { var mapHst = new MapHaltestelleModel() { Id = h.Id, Bezeichnung = h.Bezeichnung, GeoCoordinate = new GeoCoordinate(h.Latitude, h.Longitude) }; mapPins.Add(mapHst); } catch (Exception) { // ArgumentOutOfRangeException from new GeoCoordinate(..., ...): we then do not show this station } } NearbyStations = new BindableCollection<MapHaltestelleModel>(mapPins); NotifyOfPropertyChange(() => NearbyStations); _eventAggregator.Publish(new ZoomMapToPinsMessage(), _eventAggregator.PublishOnUIThread); }
public FileSwitchDialogViewModel(LayoutElementViewModel layoutElement) { m_layoutElement = layoutElement; m_files = m_layoutElement.FileUseOrder; m_switchFileCommand = new GenericManualCommand<int>(SwitchFile, null, Converter); m_showCloseButton = false; }
public MonstersViewModel(ILibrary library, IEventAggregator eventAggregator) { this.DisplayName = "monsters"; this.eventAggregator = eventAggregator; this.library = library; this.items = this.library.Monsters; }
public EmailListViewModel() { var now = DateTimeOffset.Now; this.emails = new BindableCollection<EmailViewModel> { new EmailViewModel { Sender = "Margaret G. Melton", Subject = "Sanitary Checks Tomorrow", Received = now.Subtract(TimeSpan.FromMinutes(2)) }, new EmailViewModel { Sender = "Samuel B. Sanchez", Subject = "More Rats in the Study", Received = now.Subtract(TimeSpan.FromDays(1)) }, new EmailViewModel { Sender = "Samuel B. Sanchez", Subject = "Rats in the Basement", Received = now.Subtract(TimeSpan.FromHours(25)) }, new EmailViewModel { Sender = "Janice K. Burson", Subject = "Dirty Chicken Sink", Received = now.Subtract(TimeSpan.FromDays(2)) } }; this.selectedEmails = new BindableCollection<EmailViewModel>(); }
public RoomViewModel(Room room) { this.room = room; this.dispatcher = Dispatcher.CurrentDispatcher; this.messages = new BindableCollection<IMessageViewModel>(); this.users = new BindableCollection<User>(); }
protected override void OnInitialize() { base.OnInitialize(); _bugRepository.BugSaved += (s, e) => { if (!Bugs.Contains(e.Bug)) Bugs.Add(e.Bug); }; _bugRepository.BugDeleted += (s, e) => Bugs.Remove(e.Bug); Bugs = new BindableCollection<Bug>(_bugRepository); }
public ChangeCardLabelsViewModel(object root) : base(root) { _eventAggregator = IoC.Get<IEventAggregator>(); _api = IoC.Get<ITrello>(); _progress = IoC.Get<IProgressService>(); Labels = new BindableCollection<Label>(); }
public void CreateContextMenu(FrameworkElement view, IObservableCollection<ContextMenuModel> contextMenuItems) { var contextMenu = new PopupMenu { Manager = _shell.GetMenuManager() }; BarManager.SetDXContextMenu(view, contextMenu); foreach (var item in contextMenuItems) { AddContextMenuItem(contextMenu, item); } }
protected override void OnInitialize() { base.OnInitialize(); this.RecentProjects=new BindableCollection<Project>(); for (int i = 0; i < 5; i++) this.RecentProjects.Add(new Project() { Name = "Test" + i }); NotifyOfPropertyChange(()=> this.NoRecentProjects); }
public PreAssignedCollectionViewModel( IObservableCollection<CustomerViewModel> collection, ServiceFactory<ICustomerService> customerServiceFactory) { CustomerCollection = collection; customerServiceFactory .Collection(this, x => x.CustomerCollection) .Fill(x => x.GetCustomersWithTurnoverGreatherThan(0)); }
public MoveCardToBoardViewModel(object root) : base(root) { _eventAggregator = IoC.Get<IEventAggregator>(); _api = IoC.Get<ITrello>(); _progress = IoC.Get<IProgressService>(); Boards = new BindableCollection<Board>(); Lists = new BindableCollection<List>(); PropertyChanged += OnPropertyChanged; }
public RoomViewModel( MessageService messageService, RoomService roomService, UserService userService) { _messageService = messageService; _roomService = roomService; _userService = userService; _messages = new BindableCollection<MessageViewModel>(); _users = new BindableCollection<RoomUserViewModel>(); }
private IUndoableAction Pop(IObservableCollection <IUndoableAction> stack) { if (stack.Count == 0) { return(null); } var r = stack[stack.Count - 1]; stack.RemoveAt(stack.Count - 1); return(r); }
/// <summary> /// Construtor padrão. /// </summary> /// <param name="source">Coleção de origem com todos os dados da lista.</param> /// <param name="selectedItems">Relação dos itens selecionados.</param> /// <param name="selectionComparer">Comparador que será utilizado na solução.</param> /// <param name="selectedItemCreator">Delegate usado para cria o item selecionado.</param> public SelectionCollection(IObservableCollection <T> source, IObservableCollection <TProxy> selectedItems, SelectionEntryEqualityComparer <T, TProxy> selectionComparer, Func <T, TProxy> selectedItemCreator) { source.Require("source").NotNull(); selectedItems.Require("selectedItems").NotNull(); selectionComparer.Require("selectionComparer").NotNull(); selectedItemCreator.Require("selectedItemCreator").NotNull(); _selectionComparer = selectionComparer; _selectedItemCreator = selectedItemCreator; _selectedItems = selectedItems; Initialize(source, CreateEntryProxy, null); _selectedItems.CollectionChanged += SelectedItemsCollectionChanged; }
public static FilteredView <T> AsFilteredView <T>( this IObservableCollection <T> collection, Func <T, bool> filter, params IObservable <object?>[] triggers) { if (collection is null) { throw new ArgumentNullException(nameof(collection)); } return(new FilteredView <T>(collection, filter, TimeSpan.Zero, false, triggers)); }
public CommandsListMonitor(CommandBar bar, IObservableCollection<AppBarCommandViewModel> source) { if (bar == null) throw new ArgumentNullException("bar"); if (source == null) throw new ArgumentNullException("source"); _bar = bar; _source = source; _bar.Unloaded += OnUnloaded; _source.CollectionChanged += OnCollectionChanged; }
public CategoryDesign() { Category = SampleCategory.Dialogs; Items = new BindableCollection <ISample> { new GenericSampleDesign(), new GenericSampleDesign() }; NextSamples = new BindableCollection <string>() { "Foo", "Bar" }; ActiveItem = Items[0]; }
private void ResetListBinder() { if (this.dataList != null) { this.dataList.OnObjectAdd -= new Action <object>(this.OnAdd); this.dataList.OnObjectRemove -= new Action <object>(this.OnRemove); this.dataList.OnClear -= new Action(this.OnClear); } this.dataList = null; this.alldataList.Clear(); this.OnClear(); }
public static FilteredView <T> AsFilteredView <T>( this IObservableCollection <T> collection, Func <T, bool> filter, TimeSpan bufferTime, IScheduler scheduler, params IObservable <object>[] triggers) { Ensure.NotNull(collection, nameof(collection)); Ensure.NotNull(filter, nameof(filter)); Ensure.NotNull(scheduler, nameof(scheduler)); return(new FilteredView <T>(collection, filter, bufferTime, scheduler, triggers)); }
public TodoItemViewModel(TodoItem item) { this.item = item; this.tags = new BindableCollection <TagViewModel>(); foreach (var tag in item.Tags) { var model = new TagViewModel(tag); this.tags.Add(model); model.OnRemove += this.OnRemoveTag; } }
public CardDetailChecklistViewModel(IEventAggregator eventAggregator, IWindowManager window, Func <ChecklistViewModel> checklistFactory) { DisplayName = "checklists"; _eventAggregator = eventAggregator; _window = window; _checklistFactory = checklistFactory; Checklists = new BindableCollection <ChecklistViewModel>(); }
private void Properties_Changed(IList <object> propertyGroups) { if (propertyGroups == null) { return; } _projectPropertyNames = propertyGroups.ObservableSelectMany(group => ((CollectionViewGroup)group).Items); _projectPropertyNames.CollectionChanged += (sender, e) => ProjectProperties_CollectionChanged(e); Initialize(); }
public ProcessListViewModel(IRemoteProcessService processService, IBus bus) : base(bus) { this.processService = processService; Contract.Requires <ArgumentNullException>(processService != null); Contract.Requires <ArgumentNullException>(bus != null); this.processModulesCollection = new BindableCollection <IProcessModules>(); this.processService.GetAll().Where(p => p.IsAttached).Apply(this.AddProcessModules); this.Title = "Processes"; this.Bus.Subscribe(this); }
public AttachToProcessViewModel( IRemoteProcessService remoteProcessService, IRemoteProcessCommandService remoteProcessCommandService) { Contract.Requires<ArgumentNullException>(remoteProcessService != null); Contract.Requires<ArgumentNullException>(remoteProcessCommandService != null); this.remoteProcessService = remoteProcessService; this.remoteProcessCommandService = remoteProcessCommandService; this.remoteProcesses = this.remoteProcessService.GetAll(); this.selectedItems = new BindableCollection<IRemoteProcess>(); this.selectedItems.CollectionChanged += (sender, args) => this.NotifyOfPropertyChange(() => this.CanAttach); }
/// <summary> /// Initializes a new instance of the <see cref="EditableListView{T}"/> class. /// </summary> /// <param name="list">The collection to decorate.</param> /// <param name="leaveOpen">True means that <paramref name="list"/> is not disposed when this instance is diposed.</param> public EditableListView(IObservableCollection <T> list, bool leaveOpen) : base(list) { this.leaveOpen = leaveOpen; this.subscriptions = new CompositeDisposable(2) { list.ObservePropertyChangedSlim() .Subscribe(this.OnPropertyChanged), list.ObserveCollectionChangedSlim(signalInitial: false) .Subscribe(this.OnCollectionChanged), }; }
protected override void Dispose(bool disposing) { base.Dispose(disposing); if (disposing) { if (boundCollection != null) { boundCollection.CollectionChanged -= itemsChangedHandler; } boundCollection = null; } }
public TodoItemViewModel(TodoItem item) { this.item = item; this.tags = new BindableCollection<TagViewModel>(); foreach (var tag in item.Tags) { var model = new TagViewModel(tag); this.tags.Add(model); model.OnRemove += this.OnRemoveTag; } }
public AttachToProcessViewModel( IRemoteProcessService remoteProcessService, IRemoteProcessCommandService remoteProcessCommandService) { Contract.Requires <ArgumentNullException>(remoteProcessService != null); Contract.Requires <ArgumentNullException>(remoteProcessCommandService != null); this.remoteProcessService = remoteProcessService; this.remoteProcessCommandService = remoteProcessCommandService; this.remoteProcesses = this.remoteProcessService.GetAll(); this.selectedItems = new BindableCollection <IRemoteProcess>(); this.selectedItems.CollectionChanged += (sender, args) => this.NotifyOfPropertyChange(() => this.CanAttach); }
void BindingAdd(IObservableCollection col, object item) { Game.RunAfterTick(() => { if (collection != col) { return; } BindingAddImpl(item); }); }
public CollectionSyncer(ICollection <T> t, Func <T, U> create) { _create = create; INotifyCollectionChanged collection = t as INotifyCollectionChanged; if (collection == null) { throw new ArgumentException("The ICollection<T> must be INotifyCollectionChanged"); } CollectionChangedEventManager.AddListener(collection, this); _syncCollection = new BindableCollection <U>(); t.Apply(item => _syncCollection.Add(_create(item))); }
public View(IObservableCollection <T> source, Func <T, TView> selector, bool reverse) { this.source = source; this.selector = selector; this.reverse = reverse; this.filter = SynchronizedViewFilter <T, TView> .Null; this.SyncRoot = new object(); lock (source.SyncRoot) { this.ringBuffer = new RingBuffer <(T, TView)>(source.Select(x => (x, selector(x)))); this.source.CollectionChanged += SourceCollectionChanged; } }
public ProjectDependenciesViewModel([NotNull] Solution solution) { Contract.Requires(solution != null); _references = solution.Projects.ObservableSelect(project => new ProjectDependency(this, null, project, proj => proj.References)); _referencedBy = solution.Projects.ObservableSelect(project => new ProjectDependency(this, null, project, proj => proj.ReferencedBy)); Groups = new[] { new ProjectDependencyGroup("References", _references), new ProjectDependencyGroup("Referenced By", _referencedBy), }; }
public ChecklistViewModel(ITrelloApiSettings settings, INavigationService navigation, IEventAggregator eventAggregator, IWindowManager windows, Func <ChecklistItemViewModel> itemFactory) : base(settings, navigation) { _itemFactory = itemFactory; _eventAggregator = eventAggregator; _windows = windows; _eventAggregator.Subscribe(this); Items = new BindableCollection <ChecklistItemViewModel>(); }
public async void SearchForMatchesAsync(string searchString) { if (!CanStartSearch(searchString)) return; Haltestellen = null; NotifyOfPropertyChange(() => Haltestellen); var result = await _dataService.GetHaltestellenContainingAsync(searchString); Haltestellen = new BindableCollection<Haltestelle>(result); NotifyOfPropertyChange(() => Haltestellen); }
/// <summary> /// Construtor padrão. /// </summary> /// <param name="name">Nome do indice.</param> /// <param name="collection">Coleção que será observada.</param> /// <param name="watchProperties">Relação das propriedades assistidas.</param> /// <param name="keyGetter">Ponteiro do método usado para recupera o valor da chave do item.</param> /// <param name="comparer">Comparador que será utilizado.</param> public ObservableCollectionIndex(string name, IObservableCollection <T> collection, string[] watchProperties, Func <T, object> keyGetter, System.Collections.IComparer comparer) { name.Require("name").NotNull().NotEmpty(); collection.Require("collection").NotNull(); keyGetter.Require("keyGetter").NotNull(); comparer.Require("comparer").NotNull(); _name = name; _collection = collection; _watchProperties = watchProperties ?? new string[0]; _keyGetter = keyGetter; _comparer = comparer; _collection.CollectionChanged += CollectionCollectionChanged; }
/// <summary> /// Libera a instancia. /// </summary> /// <param name="disposing"></param> protected virtual void Dispose(bool disposing) { if (_source != null) { _source.CollectionChanged -= SourceCollectionChanged; foreach (var item in _source) { UnregisterItem(item); } } _source = null; _indexes.Dispose(); }
public CollectionTreeViewModel(IObservableCollection<string> paths = null) { m_paths = paths; if (paths != null) { foreach (string path in paths) { if (Directory.Exists(path)) m_children.Add(new DirectoryViewModel(path)); } paths.CollectionChanged += PathsOnCollectionChanged; } }
public ShellViewModel([ImportMany] IEnumerable <ISample> samples) { DisplayName = "CMContrib WPF Demo"; LogItems = new BindableCollection <string>(); SamplesByCategory = new BindableCollection <CategorySamples>(); foreach (var samplesByCategory in samples .GroupBy(x => x.Category) .OrderBy(x => x.Key.ToString())) { SamplesByCategory.Add(new CategorySamples(samplesByCategory.Key, new BindableCollection <ISample>(samplesByCategory))); } }
public EditorManager(IFileViewModel setting, MainViewModel mainViewModel) { m_editorsWithSettings = new FilteredObservableCollection<IEditor>(m_baseEditors, editor => editor.Settings != null); m_setting = setting; m_mainViewModel = mainViewModel; m_imageViewerViewModel = new ImageViewerViewModel(); m_jsonEditorViewModel = new JsonEditorViewModel(mainViewModel); m_simpleEditor = new BaseTextEditorViewModel(mainViewModel); m_findInFilesViewModel = new FindInFilesViewModel(mainViewModel); UpdateSettings(); m_setting.ContentChanged += SettingOnContentChanged; }
// Initializations #region Initializations public ShellViewModel(IThemeManager themeManager, IMenu mainMenu, IToolBarTray toolBarTray, IStatusBar statusBar) { _themeManager = themeManager; MainMenu = mainMenu; StatusBar = statusBar; ToolBarTray = toolBarTray; Tools = new BindableCollection <ITool>(); _closing = false; }
public TestSocketVM() { _localSettings = ApplicationData.Current.LocalSettings; _inComes = new ObservableCollectionExtended <ClientInComeMessage>(); var canConnect = this.WhenAnyValue(vm => vm.HostName, vm => vm.Port, vm => vm.IsConnect, (hostname, port, isconnect) => !string.IsNullOrWhiteSpace(hostname) && port > 1000 && !isconnect); var canSendMessage = this.WhenAnyValue(vm => vm.TextMessage, vm => vm.IsConnect, (t, isconnect) => !string.IsNullOrWhiteSpace(t) && isconnect); Connect2Server = ReactiveCommand.CreateFromTask(_connect2Server, canConnect); Disconnect4Server = ReactiveCommand.Create(_disconnect4Server); SendMessage = ReactiveCommand.CreateFromTask(_sendMessage, canSendMessage); HostName = (string)_localSettings.Values["HostName"] ?? ""; Port = uint.Parse(_localSettings.Values["Client.Port"]?.ToString() ?? "1000"); }
/// <summary> /// Constructor with collection and reference creator function</summary> /// <param name="collection">Collection</param> /// <param name="createReference">Reference creator function</param> public ReferenceCollectionAdapter(IObservableCollection <IReference <TRefTarget> > collection, Func <U, IReference <TRefTarget> > createReference) : base(collection) { m_collection = collection; m_createReference = createReference; m_targetToRefMap = new Dictionary <U, IReference <TRefTarget> >(); foreach (var item in m_collection) { m_targetToRefMap.Add(item.Target.As <U>(), item); } m_collection.CollectionChanged += CollectionCollectionChanged; }
public Node(string name, bool isExpanded, BitmapImage icon, IObservableCollection <ResourceViewModel> resources = null, IObservableCollection <Node> children = null) { _name = name; _isExpanded = isExpanded; _icon = icon; Nodes = children ?? new ObservableCollection <Node>(); if (resources != null) { Resources = resources; Resources.PropertyChanged += ResourcesOnPropertyChanged; _propChangedName = new ActionDeferrer(() => Notify("Name"), TimeSpan.FromSeconds(0.5), Dispatcher.CurrentDispatcher); } }
public PacketListViewModel( Guid processId, PacketFactory packetFactory, IOpenPacketDetails openPacketDetails, IDataSource dataSource) { Contract.Requires <ArgumentNullException>(packetFactory != null); Contract.Requires <ArgumentNullException>(openPacketDetails != null); Contract.Requires <ArgumentNullException>(dataSource != null); this.processId = processId; this.packetFactory = packetFactory; this.openPacketDetails = openPacketDetails; this.dataSource = dataSource; this.packets = new BindableCollection <PacketViewModel>(); }
/// <summary> /// Filters the sequence using the specified <paramref name="wherePredicate"/>. /// </summary> /// <typeparam name="TElement">Type of elements in the collection</typeparam> /// <param name="collection">Collection to filter</param> /// <param name="wherePredicate">Predicate used for filtering</param> /// <returns>Observable enumerable with filtered elements</returns> public static IObservableCollectionSubset <TElement> Where <TElement>(this IObservableCollection <TElement> collection, Predicate <TElement> wherePredicate) { if (collection == null) { throw new NullReferenceException(); } if (wherePredicate == null) { throw new ArgumentNullException(nameof(wherePredicate)); } return(new ObervableCollectionSubset <TElement>(collection, wherePredicate)); }
private TextBand NewTitle(IObservableCollection collection, string text) { TextBand result = new TextBand(collection); result.Text = text; result.Format.Font.Size = 12; result.Format.Font.Style = Steema.TeeGrid.Format.FontStyle.Bold; result.Format.Font.Color = ColorTranslator.FromHtml("#034684"); result.Format.Stroke.Visible = true; result.Format.Stroke.Size = 3; result.Format.Stroke.Color = ColorTranslator.FromHtml("#6BABD0"); return(result); }
public DirectoryViewModel(string path, ITreeNode parrent = null, IObservableCollection<FileViewModel> allFiles = null, SynchronizationContext synchronizationContext = null) { if (synchronizationContext == null) { if (parrent is DirectoryViewModel) synchronizationContext = ((DirectoryViewModel)parrent).m_synchronizationContext; if (synchronizationContext == null) synchronizationContext = SynchronizationContext.Current; } Debug.Assert(synchronizationContext != null, "SynchronizationContext should not be null"); m_synchronizationContext = synchronizationContext; m_children = new SortedObservableCollection<ITreeNode>(new AsyncObservableCollection<ITreeNode>(synchronizationContext), (node, treeNode) => (String.Compare(node.Name, treeNode.Name, StringComparison.Ordinal) + (node is DirectoryViewModel ? -1000 : 0) + (treeNode is DirectoryViewModel ? 1000 : 0)), m_synchronizationContext); m_path = path; m_parrent = parrent; m_name = System.IO.Path.GetFileName(path); if (!Directory.Exists(path)) return; if (allFiles == null) { m_allFiles = new SortedObservableCollection<FileViewModel>(new AsyncObservableCollection<FileViewModel>(), (model, viewModel) => String.Compare(model.Name, viewModel.Name, StringComparison.Ordinal)); allFiles = AllFiles; } foreach (string directory in Directory.GetDirectories(path)) Children.Add(new DirectoryViewModel(directory, this, allFiles, m_synchronizationContext)); foreach (string file in Directory.GetFiles(path)) { FileViewModel fileViewModel = new FileViewModel(file, this); Children.Add(fileViewModel); allFiles.Add(fileViewModel); } if (parrent == null) { m_externalChanges = new Dictionary<string, DateTime>(); m_fileSystemWatcher = new FileSystemWatcher(path) { NotifyFilter = NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.LastWrite, IncludeSubdirectories = true }; m_fileSystemWatcher.Created += FileSystemWatcherOnCreated; m_fileSystemWatcher.Deleted += FileSystemWatcherOnDeleted; m_fileSystemWatcher.Changed += FileSystemWatcherOnChanged; m_fileSystemWatcher.Renamed += FileSystemWatcherOnRenamed; m_fileSystemWatcher.EnableRaisingEvents = true; m_cleanUpTimer = new Timer(ClanUp, null, 5000, Timeout.Infinite); } }
public UnionCollection(IObservableCollection <TFirst> first, IObservableCollection <TSecond> second) { if (first != null) { _first = first; first.CollectionChanged += First_CollectionChanged; } if (second != null) { second.CollectionChanged += SecondOnCollectionChanged; _second = second; } _enumerator = new UnionEnumerator <TFirst, TSecond, TCommon>(first, second); }
public ChatMessageGroupViewModel(ChatMessageViewModel message) : base(false) { IsNotifying = false; _messages = new BindableCollection<ChatMessageViewModel> {message}; _messages.CollectionChanged += MessagesOnCollectionChanged; _user = message.User; MessageDateTime = message.MessageDateTime; MessageId = message.MessageId; LastMessageDateTime = message.MessageDateTime; IsNotifying = true; }
public PositionsViewModel(IClient client) { this.DisplayName = "Positions"; this.positions = new BindableCollection<Position>(); foreach (var position in client.Accounts.SelectMany(accounts => accounts.PositionsStorage.Positions)) { this.positions.Add(new Position(position)); } foreach (var account in client.Accounts) { account.PositionsStorage.PositionAdded += (sender, eventArgs) => this.positions.Add(new Position(eventArgs.Position)); } }
public GraphicsCompositorGraph([NotNull] IObservableCollection <IGraphicsCompositorBlockViewModel> blocks, IObservableCollection <IGraphicsCompositorBlockViewModel> selectedBlocks, IObservableCollection <IGraphicsCompositorLinkViewModel> selectedLinks) { if (blocks == null) { throw new ArgumentNullException(nameof(blocks)); } this.blocks = blocks; this.selectedBlocks = selectedBlocks; this.selectedLinks = selectedLinks; blocks.CollectionChanged += BlocksCollectionChanged; selectedBlocks.CollectionChanged += SelectedBlocksCollectionChanged; selectedLinks.CollectionChanged += SelectedLinksCollectionChanged; selectedVertices.CollectionChanged += SelectedVerticesCollectionChanged; selectedEdges.CollectionChanged += SelectedEdgesCollectionChanged; }
protected override void OnActivate() { base.OnActivate(); this.host.GetGenres(genres => { if (genres == null) { this.navigationService.GoBack(); return; } this.Genres = new BindableCollection<GenreViewModel>(genres); NotifyOfPropertyChange(() => this.Genres); }); }
public OrdersViewModel(IClient client) { this.DisplayName = "Orders"; this.orders = new BindableCollection<OrderView>(); foreach (var order in client.Accounts.SelectMany(account => account.OrdersStorage.Orders)) { this.Orders.Add(new OrderView(order)); } foreach (var account in client.Accounts) { account.OrdersStorage.OrderAdded += this.OnOrderAdded; } }
public ExecutionsViewModel(IClient client) { this.DisplayName = "Executions"; this.executions = new BindableCollection<ExecutionView>(); foreach (var execution in client.Accounts.SelectMany(account => account.ExecutionsStorage.Executions)) { this.executions.Add(new ExecutionView(execution)); } foreach (var account in client.Accounts) { account.ExecutionsStorage.ExecutionAdded += this.OnExecutionAdded; } }
protected override void OnActivate() { base.OnActivate(); this.host.ListMovies(movies => { if (movies == null) { this.navigationService.GoBack(); return; } this.Movies = new BindableCollection<MovieViewModel>(movies.Select(m => new MovieViewModel(host, navigationService, m))); NotifyOfPropertyChange(() => Movies); }); }
private void ItemsLoadCompleted(object sender, LoadCompletedEventArgs e) { if (e.Cancelled) { } else if (e.Error != null) { } else { AllProjects = new BindableCollection<Project>(_collection); this.NotifyOfPropertyChange(()=> this.AllProjects); } }
public ProcessModulesViewModel(IRemoteProcess remoteProcess, IItem processDetails, IEnumerable<IModule> modules) { Contract.Requires<ArgumentNullException>(remoteProcess != null); Contract.Requires<ArgumentNullException>(processDetails != null); Contract.Requires<ArgumentNullException>(modules != null); this.remoteProcess = remoteProcess; this.processDetails = processDetails; this.iconSource = null; this.modules = new BindableCollection<IModule>(modules); var inpc = remoteProcess as INotifyPropertyChanged; if (inpc == null) { return; } PropertyChangedEventManager.AddHandler( inpc, (sender, args) => this.NotifyOfPropertyChange(() => this.Name), string.Empty); }
public MainMenuViewModel(IShortcut[] menuItems) { this.menuItems = new BindableCollection<IShortcut>(menuItems); }
public void Bind(IObservableCollection c, Func<object, Widget> makeWidget, Func<Widget, object, bool> widgetItemEquals, bool autoScroll) { this.autoScroll = autoScroll; Game.RunAfterTick(() => { if (collection != null) { collection.OnAdd -= BindingAdd; collection.OnRemove -= BindingRemove; collection.OnRemoveAt -= BindingRemoveAt; collection.OnSet -= BindingSet; collection.OnRefresh -= BindingRefresh; } this.makeWidget = makeWidget; this.widgetItemEquals = widgetItemEquals; RemoveChildren(); collection = c; if (c != null) { foreach (var item in c.ObservedItems) BindingAddImpl(item); c.OnAdd += BindingAdd; c.OnRemove += BindingRemove; c.OnRemoveAt += BindingRemoveAt; c.OnSet += BindingSet; c.OnRefresh += BindingRefresh; } }); }
public Solution(ITracer tracer, IVsServiceProvider serviceProvider) { Contract.Requires(tracer != null); Contract.Requires(serviceProvider != null); _deferredUpdateThrottle = new DispatcherThrottle(DispatcherPriority.ContextIdle, Update); _tracer = tracer; _serviceProvider = serviceProvider; _specificProjectConfigurations = Projects.ObservableSelectMany(prj => prj.SpecificProjectConfigurations); _solutionContexts = SolutionConfigurations.ObservableSelectMany(cfg => cfg.Contexts); _defaultProjectConfigurations = Projects.ObservableSelect(prj => prj.DefaultProjectConfiguration); _projectConfigurations = new ObservableCompositeCollection<ProjectConfiguration>(_defaultProjectConfigurations, _specificProjectConfigurations); _solutionEvents = Dte?.Events?.SolutionEvents; if (_solutionEvents != null) { _solutionEvents.Opened += Solution_Changed; _solutionEvents.AfterClosing += Solution_Changed; _solutionEvents.ProjectAdded += _ => Solution_Changed(); _solutionEvents.ProjectRemoved += _ => Solution_Changed(); _solutionEvents.ProjectRenamed += (_, __) => Solution_Changed(); } Update(); }