public OptionsViewModel(OptionsPageData data, ObservableValue<IEnumerable<string>> exceptionNames)
{
_data = data;
IgnoredPatterns = new PatternCollectionViewModel(data.Ignored);
AllExceptions = exceptionNames.GetObservable(v => new ReadOnlyCollection<ExceptionViewModel>(
v.Select(n => new ExceptionViewModel(n, IgnoredPatterns.Selected)).ToArray()
));
_exceptionsMatchingIgnored = new ObservableCollection<ExceptionViewModel>();
ExceptionsMatchingIgnored = new ReadOnlyObservableCollection<ExceptionViewModel>(_exceptionsMatchingIgnored);
AllExceptions.ValueChanged += (sender, e) => RecalculateExceptionsMatchingIgnored();
IgnoredPatterns.Values.CollectionChanged += (sender, e) => RecalculateExceptionsMatchingIgnored();
var ignoredChangeHandler = (EventHandler) delegate { RecalculateExceptionsMatchingIgnored(); };
IgnoredPatterns.Values.AddHandlers(
added => {
added.Pattern.ValueChanged += ignoredChangeHandler;
added.Enabled.ValueChanged += ignoredChangeHandler;
},
removed => {
removed.Pattern.ValueChanged -= ignoredChangeHandler;
removed.Enabled.ValueChanged -= ignoredChangeHandler;
}
);
RecalculateExceptionsMatchingIgnored();
}
public RecipesViewModel()
{
// initialize commands
m_addNewRecipeCommand = new RelayCommand(AddNewRecipe);
m_deleteRecipeCommand = new RelayCommand<RecipeDataModel>(DeleteRecipe);
m_addHopsIngredientToRecipeCommand = new RelayCommand<Hops>(AddHopsIngredient);
m_addFermentableIngredientToRecipeCommand = new RelayCommand<Fermentable>(AddFermentableIngredient);
m_changeYeastCommand = new RelayCommand<Yeast>(ChangeYeast);
m_deleteHopsIngredientCommand = new RelayCommand<IHopsIngredient>(DeleteHopsIngredient);
m_deleteFermentableIngredientCommand = new RelayCommand<IFermentableIngredient>(DeleteFermentableIngredient);
// get available ingredients
List<IngredientTypeBase> allAvailableIngredients = RecipeUtility.GetAvailableIngredients().OrderBy(ingredient => ingredient.Name).ToList();
m_availableHops = allAvailableIngredients.OfType<Hops>().ToReadOnlyObservableCollection();
m_availableFermentables = allAvailableIngredients.OfType<Fermentable>().ToReadOnlyObservableCollection();
m_availableYeasts = allAvailableIngredients.OfType<Yeast>().ToReadOnlyObservableCollection();
List<Style> beerStyles = RecipeUtility.GetAvailableBeerStyles().OrderBy(style => style.Name).ToList();
m_availableBeerStyles = beerStyles.ToReadOnlyObservableCollection();
m_savedRecipes = new ObservableCollection<RecipeDataModel>(RecipeUtility.GetSavedRecipes(beerStyles));
GetSettings();
// set the current recipe to the first in the collection
CurrentRecipe = m_savedRecipes.FirstOrDefault();
}
protected override void InstantiationFinished()
{
base.InstantiationFinished();
Users = CreateObservableCollection(m_users);
AddNewUserCommand = new RelayCommand(AddNewUser);
}
/// <summary>
/// Initializes a new instance of the FilterRulePanelController class.
/// </summary>
public FilterRulePanelController()
{
this.filterRulePanelItems =
new ObservableCollection<FilterRulePanelItem>();
this.readOnlyFilterRulePanelItems =
new ReadOnlyObservableCollection<FilterRulePanelItem>(this.filterRulePanelItems);
}
public StorageServicesAdapter(PortableDevice device)
{
this.device = device;
portableDeviceClass = device.PortableDeviceClass;
storages = new ObservableCollection<PortableDeviceFunctionalObject>(ExtractStorageServices());
Storages = new ReadOnlyObservableCollection<PortableDeviceFunctionalObject>(storages);
}
/// <summary>
/// Constuctor.
/// </summary>
/// <param name="viewModelStore">The store this view model belongs to.</param>
/// <param name="modelTreeView">Diagram tree view.</param>
public SerializationViewModel(ViewModelStore viewModelStore, SerializationModel serializationModel)
: base(viewModelStore)
{
this.allVMs = new ObservableCollection<SerializedDomainModelViewModel>();
this.serializationModel = serializationModel;
this.selectedVMS = new Collection<object>();
this.rootVMs = new ObservableCollection<SerializedDomainModelViewModel>();
this.rootVMsRO = new ReadOnlyObservableCollection<SerializedDomainModelViewModel>(this.rootVMs);
this.selectRelationshipCommand = new DelegateCommand(SelectRelationshipCommand_Executed);
this.moveUpCommand = new DelegateCommand(MoveUpCommand_Executed, MoveUpCommand_CanExecute);
this.moveDownCommand = new DelegateCommand(MoveDownCommand_Executed, MoveDownCommand_CanExecute);
if (this.serializationModel.SerializedDomainModel != null)
{
this.rootVMs.Add(new SerializedDomainModelViewModel(this.ViewModelStore, this.serializationModel.SerializedDomainModel));
}
if (this.serializationModel != null)
{
foreach (SerializationClass c in this.serializationModel.Children)
if (c is SerializedDomainClass)
this.AddChild(c as SerializedDomainClass);
this.EventManager.GetEvent<ModelElementLinkAddedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(SerializationModelHasChildren.DomainClassId),
true, this.serializationModel.Id, new System.Action<ElementAddedEventArgs>(OnChildAdded));
this.EventManager.GetEvent<ModelElementLinkDeletedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(SerializationModelHasChildren.DomainClassId),
true, this.serializationModel.Id, new System.Action<ElementDeletedEventArgs>(OnChildRemoved));
}
}
public MiniMapWindow(Route route, Region region)
{
InitializeComponent();
Region = region;
var waypoints = new List<Waypoint>();
var connections = new List<Connection>();
foreach (var conn in route.Path)
{
if (conn.Source.Region == region)
waypoints.Add(conn.Source);
if (conn.Target.Region == region)
waypoints.Add(conn.Target);
if (conn.Source.Region == region && conn.Target.Region == region)
connections.Add(conn);
}
Waypoints = new ReadOnlyObservableCollection<Waypoint>(new ObservableCollection<Waypoint>(waypoints));
Connections = new ReadOnlyObservableCollection<Connection>(new ObservableCollection<Connection>(connections));
DataContext = this;
}
public MainWindowViewModel() {
Pokemons = new ReadOnlyObservableCollection<SniperInfoModel>(GlobalVariables.PokemonsInternal);
SettingsComand = new ActionCommand(ShowSettings);
StartStopCommand = new ActionCommand(Startstop);
DebugComand = new ActionCommand(ShowDebug);
Settings.Default.DebugOutput = "Debug stuff in here!";
//var poke = new SniperInfo {
// Id = PokemonId.Missingno,
// Latitude = 45.99999,
// Longitude = 66.6677,
// ExpirationTimestamp = DateTime.Now
//};
//var y = new SniperInfoModel {
// Info = poke,
// Icon = new BitmapImage(new Uri(Path.Combine(iconPath, $"{(int) poke.Id}.png")))
//};
//GlobalVariables.PokemonsInternal.Add(y);
GlobalSettings.Output = new Output();
Program p = new Program();
Thread a = new Thread(p.Start) { IsBackground = true};
//Start(); p
a.Start();
}
public NotificationInfoContainer(PlatformClient client, bool isReadedItemOnly)
: base(client)
{
_isReadedItemOnly = isReadedItemOnly;
_notifications = new ObservableCollection<NotificationInfo>();
Notifications = new ReadOnlyObservableCollection<NotificationInfo>(_notifications);
}
public ChatRoom(ChatServerImpl server)
{
_server = server;
_users = new ObservableCollection<IChatUser>();
Users = new ReadOnlyObservableCollection<IChatUser>(_users);
RoomId = Guid.NewGuid().ToString("N");
}
public ServersList(ServersListMessage msg)
{
if (msg == null) throw new ArgumentNullException("msg");
m_collection = new ObservableCollection<ServersListEntry>(msg.servers.Select(entry => new ServersListEntry(entry)));
m_readOnlyCollection = new ReadOnlyObservableCollection<ServersListEntry>(m_collection);
}
public WorkspaceViewModel(TraceLab.Core.Workspaces.Workspace workspace, string experimentId)
{
if (workspace == null)
throw new ArgumentNullException("workspace");
if (String.IsNullOrEmpty(experimentId))
throw new ArgumentException("Experiment id cannot be null or empty", "experimentId");
m_workspace = workspace;
m_workspace.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(workspace_PropertyChanged);
m_experimentId = experimentId;
//init observable collections
m_experimentWorkspaceUnits = new ObservableCollection<WorkspaceUnit>();
m_readonlyExperimentWorkspaceUnits = new ReadOnlyObservableCollection<WorkspaceUnit>(m_experimentWorkspaceUnits);
//prefill local units with units of this experiment
foreach (WorkspaceUnit unit in m_workspace.Units)
{
AddUnit(unit);
}
INotifyCollectionChanged workspaceUnitCollection = m_workspace.Units;
workspaceUnitCollection.CollectionChanged += WorkspaceCollectionCollectionChanged;
(new TraceLab.Core.Components.LibraryHelper(m_workspace.TypeDirectories)).PreloadWorkspaceTypes(System.AppDomain.CurrentDomain);
}
public SelectionFileForDownloadingViewModel(ReadOnlyObservableCollection<HexFileViewModel> files)
{
this.files = files;
IndexOfTheSelectedFile = 0;
OkCommand = new DelegateCommand(OnOk);
CloseCommand = new DelegateCommand(OnClose);
}
public AudioEffect(AudioContext context, AudioEffectType type)
: base(context, Create(context))
{
using (Context.Bind())
Context.AlEffecti(Id, AlEfxEnums.EffectType, (int)type);
sourcesReadOnly = new ReadOnlyObservableCollection<AudioSource>(sources);
}
public MainWindowViewModel(
IAssigmentsCache assigmentsCache,
ITagsCache tagsCache,
IAddAssigmentService addAssigmentService,
Func<IAssigment, IAssigmentViewModel> assigmentViewModelFactory,
Func<ITag, ISelectableTagViewModel> tagViewModelFactory)
{
ApplicationTitle = "ToDo";
Assigments = new ReadOnlyObservableCollection<IAssigmentViewModel>(_assigments);
AvalibleTags = new ReadOnlyObservableCollection<ISelectableTagViewModel>(_avalibleTags);
AddAssigment = new AddAssigmentCommand(this);
_addAssigmentService = addAssigmentService;
_assigmentViewModelFactory = assigmentViewModelFactory;
_tagViewModelFactory = tagViewModelFactory;
foreach (var assigment in assigmentsCache.Items)
{
_assigments.Add(assigmentViewModelFactory(assigment));
}
assigmentsCache.AssimentAdded += OnAssimentAdded;
foreach (var tag in tagsCache.Items)
{
_avalibleTags.Add(_tagViewModelFactory(tag));
}
tagsCache.TagAdded += OnTagAdded;
}
public TimeModule()
{
_bookmarks = new ReadOnlyObservableCollection<Bookmark>(new ObservableCollection<Bookmark>());
MapViewTimeChangedEvent.Subscribe(OnTimeChanged);
ActiveMapViewChangedEvent.Subscribe(OnActiveMapViewChanged);
LoadBookmarks();
}
public void Select_ReadOnlyObservableCollection_InputContentsMatchOutputContents()
{
var readOnlySource = new ReadOnlyObservableCollection<Person>(_source);
ReadOnlyContinuousCollection<Person> output = from person in readOnlySource
select person;
Assert.AreEqual(readOnlySource, output);
}
public PersonEntry(ILocationService locationService, IAddress address)
{
_locationService = locationService;
_address = address;
_roAvailableCountries = new ReadOnlyObservableCollection<ICountry>(_availableCountries);
}
public SessionsViewModel()
{
r_Sessions = new ObservableCollection<Session>();
Sessions = new ReadOnlyObservableCollection<Session>(r_Sessions);
KanColleGame.Current.Proxy.NewSession += r => DispatcherUtil.UIDispatcher.BeginInvoke(new Action<Session>(r_Sessions.Add), r);
}
/// <summary>
/// Constuctor.
/// </summary>
/// <param name="viewModelStore">The store this view model belongs to.</param>
public MainSurfaceViewModel(ViewModelStore viewModelStore)
: base(viewModelStore)
{
this.rootNodeVMs = new ObservableCollection<ModelContextViewModel>();
this.rootNodeVMsRO = new ReadOnlyObservableCollection<ModelContextViewModel>(this.rootNodeVMs);
if (this.ModelData.MetaModel != null)
{
foreach (BaseModelContext mc in this.ModelData.MetaModel.ModelContexts)
AddModelContext(mc);
// subscribe
this.EventManager.GetEvent<ModelElementLinkAddedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(MetaModelHasModelContexts.DomainClassId),
true, this.ModelData.MetaModel.Id, new Action<ElementAddedEventArgs>(OnModelContextAdded));
this.EventManager.GetEvent<ModelElementLinkDeletedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(MetaModelHasModelContexts.DomainClassId),
true, this.ModelData.MetaModel.Id, new Action<ElementDeletedEventArgs>(OnModelContextRemoved));
if (this.ModelContextVMs.Count > 0)
this.selectedItem = this.ModelContextVMs[0];
}
this.EventManager.GetEvent<SelectionChangedEvent>().Subscribe(new Action<SelectionChangedEventArgs>(OnSelectionChanged));
}
public RecentFilesViewModel(IRecentFileCollection recentFileCollection, ISchedulerProvider schedulerProvider)
{
_recentFileCollection = recentFileCollection;
if (recentFileCollection == null) throw new ArgumentNullException(nameof(recentFileCollection));
if (schedulerProvider == null) throw new ArgumentNullException(nameof(schedulerProvider));
ReadOnlyObservableCollection<RecentFileProxy> data;
var recentLoader = recentFileCollection.Items
.Connect()
.Transform(rf => new RecentFileProxy(rf, toOpen =>
{
_fileOpenRequest.OnNext(new FileInfo(toOpen.Name));
},
recentFileCollection.Remove))
.Sort(SortExpressionComparer<RecentFileProxy>.Descending(proxy => proxy.Timestamp))
.ObserveOn(schedulerProvider.MainThread)
.Bind(out data)
.Subscribe();
Files = data;
_cleanUp = Disposable.Create(() =>
{
recentLoader.Dispose();
_fileOpenRequest.OnCompleted();
}) ;
}
public SelectProviderPage()
{
InitializeComponent();
DataContext = this;
readonlyChildren = new ReadOnlyObservableCollection<IWizardPage>(children);
// Register to self so that we can handler user interactions.
PropertyChanged += PropertyChangedHandler;
providerManager = ServiceLocator.Instance.Get<IProviderManager>();
if (providerManager != null)
{
foreach (var guid in providerManager)
{
providers.Add(providerManager.GetInformation(guid));
// If any additional page, we shall cache them with the
// same index, so make sure the collection matches providers.
additionalPages.Add(null);
}
}
LoggerName = "Untitled";
}
private DesktopStartMenuContext()
{
IsApplicationActive = true;
Entries = _programsModel.Entry.Childs;
SidePanelEntries = new ReadOnlyObservableCollection<StartPanelEntry>(_sidePanelEntries);
}
public SetLoggerNamePage()
{
InitializeComponent();
DataContext = this;
readonlyChildren = new ReadOnlyObservableCollection<IWizardPage>(children);
PropertyChanged += PropertyChangedHandler;
}
public Message()
{
textCollection = new ObservableCollection<string>();
keyCollection = new ObservableCollection<KeyPress>();
Text = new ReadOnlyObservableCollection<string>(textCollection);
Keys = new ReadOnlyObservableCollection<KeyPress>(keyCollection);
}
public DiagramLine()
{
_Visuals = new ObservableCollection<DiagramVisual>();
_Visuals.CollectionChanged += new System.Collections.Specialized.NotifyCollectionChangedEventHandler(_Visuals_CollectionChanged);
Visuals = new ReadOnlyObservableCollection<DiagramVisual>(_Visuals);
_Visuals.Add(new DiagramLineHeaderVisual());
}
/// <summary>
/// Constructor. This view model constructed with 'bHookUpEvents=true' does react on model changes.
/// </summary>
/// <param name="viewModelStore">The store this view model belongs to.</param>
/// <param name="embeddingDiagramNode">Element represented by this view model.</param>
public EmbeddingDiagramNodeViewModel(ViewModelStore viewModelStore, EmbeddingDiagramNode embeddingDiagramNode, EmbeddingDiagramNodeViewModel parent)
: base(viewModelStore, embeddingDiagramNode)
{
this.parent = parent;
this.embeddingNodeVMs = new ObservableCollection<EmbeddingDiagramNodeViewModel>();
this.embeddingNodeVMsRO = new ReadOnlyObservableCollection<EmbeddingDiagramNodeViewModel>(this.embeddingNodeVMs);
if (this.EmbeddingDiagramNode != null)
{
foreach (EmbeddingDiagramNode node in this.EmbeddingDiagramNode.EmbeddingDiagramNodes)
this.AddEmbeddingDiagramNode(node);
this.EventManager.GetEvent<ModelElementPropertyChangedEvent>().Subscribe(this.EmbeddingDiagramNode.Id, new Action<ElementPropertyChangedEventArgs>(OnElementPropertyChanged));
this.EventManager.GetEvent<ModelElementLinkAddedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(EmbeddingDiagramNodeHasEmbeddingDiagramNodes.DomainClassId),
true, this.EmbeddingDiagramNode.Id, new Action<ElementAddedEventArgs>(OnEmbeddingDiagramNodeAdded));
this.EventManager.GetEvent<ModelElementLinkDeletedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(EmbeddingDiagramNodeHasEmbeddingDiagramNodes.DomainClassId),
true, this.EmbeddingDiagramNode.Id, new Action<ElementDeletedEventArgs>(OnEmbeddingDiagramNodeRemoved));
this.EventManager.GetEvent<ModelRolePlayerMovedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(EmbeddingDiagramNodeHasEmbeddingDiagramNodes.DomainClassId),
this.EmbeddingDiagramNode.Id, new Action<RolePlayerOrderChangedEventArgs>(OnEmbeddingDiagramNodeMoved));
this.EventManager.GetEvent<ModelRolePlayerChangedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRole(EmbeddingDiagramNodeHasEmbeddingDiagramNodes.SourceEmbeddingDiagramNodeDomainRoleId),
new Action<RolePlayerChangedEventArgs>(OnEmbeddingDiagramNodeChanged));
}
expandCollapseTreeCommand = new DelegateCommand(ExpandCollapseTreeCommand_Executed);
}
public UserVM(User user, bool innerAvatarOnly)
{
Model = user;
avatar = new AvatarVM(user.Avatar, innerAvatarOnly);
commands = new ObservableCollection<MenuCommand>();
Commands = new ReadOnlyObservableCollection<MenuCommand>(commands);
}
public ReactiveFilterBase()
{
_IncludeFilters = new ObservableCollection<string>();
IncludeFilter = new ReadOnlyObservableCollection<string>(_IncludeFilters);
_ExcludeFilters = new ObservableCollection<string>();
ExcludeFilter = new ReadOnlyObservableCollection<string>(_ExcludeFilters);
}
public UserRateListViewModel(IUserInterop userInterop, IControllerInterop controllerInterop, Dispatcher dispatcher, BaseEntityDTO entity)
: base(userInterop, controllerInterop, dispatcher)
{
this.entity = entity;
rates = new ObservableCollection<UserRateItemDTO>();
Rates = new ReadOnlyObservableCollection<UserRateItemDTO>(rates);
}
private async void LoadBannerData()
{
try
{
if (CrossConnectivity.Current.IsConnected)
{
UserDialogs.Instance.ShowLoading("Loading...", MaskType.Black);
int count = 0, subonecount = 0, subtwocount = 0;
//get db data to load in mainbanner
HttpClientHelper apicall = new HttpClientHelper(string.Format(ApiUrls.Url_GetbannerImages, true), Settings.AccessTokenSettings);
var response = await apicall.GetResponse <BannerResponse>();
if (response != null)
{
if (response.banner != null)
{
if (response.banner.Count > 0)
{
foreach (var item in response.banner.ToList())
{
count++;
if (count < 7)
{
string filepath = AppSetting.Root_Url + item.ImageData;
BannerImages _bannerImg = new BannerImages();
_bannerImg.ImageId = item.ImageId;
_bannerImg.Image = filepath;
//var imageBytes = Convert.FromBase64String(item.ImageData);
//_bannerImg.Image = ImageSource.FromStream(() => new MemoryStream(imageBytes));
MainBannerImagesList.Add(_bannerImg);
}
}
}
else
{
BannerImages _bannerImg = new BannerImages();
string imagePath = AppSetting.Root_Url + "Portals/0/UrbanService/Images/banner.png";
_bannerImg.Image = imagePath;// "banner.png";
MainBannerImagesList.Add(_bannerImg);
}
}
else
{
BannerImages _bannerImg = new BannerImages();
string imagePath = AppSetting.Root_Url + "Portals/0/UrbanService/Images/banner.png";
_bannerImg.Image = imagePath;// "banner.png";
MainBannerImagesList.Add(_bannerImg);
}
}
else
{
BannerImages _bannerImg = new BannerImages();
string imagePath = AppSetting.Root_Url + "Portals/0/UrbanService/Images/banner.png";
_bannerImg.Image = imagePath;// "banner.png";
MainBannerImagesList.Add(_bannerImg);
}
MainBannerImgs = new ReadOnlyObservableCollection <BannerImages>(MainBannerImagesList);
//UserDialogs.Instance.HideLoading();
//slide show images
Device.StartTimer(TimeSpan.FromSeconds(6), () =>
{
MainSlidePosition++;
if (MainSlidePosition == MainBannerImgs.Count)
{
MainSlidePosition = 0;
}
MainPosition = MainSlidePosition;
return(true);
});
//load sub banner one data
//load sub banner one data
SubBannerOneImages banner_Img = new SubBannerOneImages();
string image_Path = AppSetting.Root_Url + "Portals/0/UrbanService/Images/AC.png";
banner_Img.SubOneImage = image_Path;
banner_Img.SubOneImagelabel = "AC";
banner_Img.Catagory = "Electrical";
SubOneBannerImagesList.Add(banner_Img);
SubBannerOneImages banner_Img1 = new SubBannerOneImages();
string image_Path1 = AppSetting.Root_Url + "Portals/0/UrbanService/Images/Fridge.png";
banner_Img1.SubOneImage = image_Path1;
banner_Img1.SubOneImagelabel = "Fridge";
banner_Img1.Catagory = "Electronics";
SubOneBannerImagesList.Add(banner_Img1);
SubBannerOneImages banner_Img2 = new SubBannerOneImages();
string image_Path2 = AppSetting.Root_Url + "Portals/0/UrbanService/Images/TV.jpg";
banner_Img2.SubOneImage = image_Path2;
banner_Img2.SubOneImagelabel = "TV ( LCD / LED )";
banner_Img2.Catagory = "Electronics";
SubOneBannerImagesList.Add(banner_Img2);
SubBannerOneImages banner_Img3 = new SubBannerOneImages();
string image_Path3 = AppSetting.Root_Url + "Portals/0/UrbanService/Images/Computer.png";
banner_Img3.SubOneImage = image_Path3;
banner_Img3.SubOneImagelabel = "Computer / Laptop";
banner_Img3.Catagory = "Electronics";
SubOneBannerImagesList.Add(banner_Img3);
SubBannerOneImages banner_Img4 = new SubBannerOneImages();
string image_Path4 = AppSetting.Root_Url + "Portals/0/UrbanService/Images/Washing_Machine.png";
banner_Img4.SubOneImage = image_Path4;
banner_Img4.SubOneImagelabel = "Washing Machine";
banner_Img4.Catagory = "Electronics";
SubOneBannerImagesList.Add(banner_Img4);
SubBannerOneImages banner_Img5 = new SubBannerOneImages();
string image_Path5 = AppSetting.Root_Url + "Portals/0/UrbanService/Images/Geyser.png";
banner_Img5.SubOneImage = image_Path5;
banner_Img5.SubOneImagelabel = "Geyser";
banner_Img5.Catagory = "Electrical";
SubOneBannerImagesList.Add(banner_Img5);
SubBannerOneImages banner_Img6 = new SubBannerOneImages();
string image_Path6 = AppSetting.Root_Url + "Portals/0/UrbanService/Images/Printer.png";
banner_Img6.SubOneImage = image_Path6;
banner_Img6.SubOneImagelabel = "Printer";
banner_Img6.Catagory = "Electronics";
SubOneBannerImagesList.Add(banner_Img6);
//load sub banner two data
SubBannerTwoImages bannerTwoImg = new SubBannerTwoImages();
string imagePathTwo = AppSetting.Root_Url + "Portals/0/UrbanService/Images/Electrician.png";
bannerTwoImg.SubTwoImage = imagePathTwo;// "banner.png";
bannerTwoImg.SubTwoImagelabel = "Electrician";
bannerTwoImg.Catagory = "Daily Services";
SubTwoBannerImagesList.Add(bannerTwoImg);
SubBannerTwoImages bannerTwoImg1 = new SubBannerTwoImages();
string imagePathTwo1 = AppSetting.Root_Url + "Portals/0/UrbanService/Images/Plumber.png";
bannerTwoImg1.SubTwoImage = imagePathTwo1;// "banner.png";
bannerTwoImg1.SubTwoImagelabel = "Plumber";
bannerTwoImg1.Catagory = "Daily Services";
SubTwoBannerImagesList.Add(bannerTwoImg1);
SubBannerTwoImages bannerTwoImg2 = new SubBannerTwoImages();
string imagePathTwo2 = AppSetting.Root_Url + "Portals/0/UrbanService/Images/Carpenter.png";
bannerTwoImg2.SubTwoImage = imagePathTwo2;// "banner.png";
bannerTwoImg2.SubTwoImagelabel = "Carpenter / Furnitur";
bannerTwoImg2.Catagory = "Daily Services";
SubTwoBannerImagesList.Add(bannerTwoImg2);
SubBannerTwoImages bannerTwoImg3 = new SubBannerTwoImages();
string imagePathTwo3 = AppSetting.Root_Url + "Portals/0/UrbanService/Images/CivilEnginner.jpg";
bannerTwoImg3.SubTwoImage = imagePathTwo3;// "banner.png";
bannerTwoImg3.SubTwoImagelabel = "Civil Engineer";
bannerTwoImg3.Catagory = "Daily Services";
SubTwoBannerImagesList.Add(bannerTwoImg3);
SubBannerTwoImages bannerTwoImg4 = new SubBannerTwoImages();
string imagePathTwo4 = AppSetting.Root_Url + "Portals/0/UrbanService/Images/PestControl.png";
bannerTwoImg4.SubTwoImage = imagePathTwo4;// "banner.png";
bannerTwoImg4.SubTwoImagelabel = "Pest Control";
bannerTwoImg4.Catagory = "Daily Services";
SubTwoBannerImagesList.Add(bannerTwoImg4);
SubBannerTwoImages bannerTwoImg5 = new SubBannerTwoImages();
string imagePathTwo5 = AppSetting.Root_Url + "Portals/0/UrbanService/Images/Painter.png";
bannerTwoImg5.SubTwoImage = imagePathTwo5;// "banner.png";
bannerTwoImg5.SubTwoImagelabel = "Painter";
bannerTwoImg5.Catagory = "Daily Services";
SubTwoBannerImagesList.Add(bannerTwoImg5);
SubBannerTwoImages bannerTwoImg6 = new SubBannerTwoImages();
string imagePathTwo6 = AppSetting.Root_Url + "Portals/0/UrbanService/Images/fabricator.png";
bannerTwoImg6.SubTwoImage = imagePathTwo6;// "banner.png";
bannerTwoImg6.SubTwoImagelabel = "Fabricator";
bannerTwoImg6.Catagory = "Daily Services";
SubTwoBannerImagesList.Add(bannerTwoImg6);
UserDialogs.Instance.HideLoading();
////get db data to load in subonebanner
//HttpClientHelper _apicall = new HttpClientHelper(string.Format(ApiUrls.Url_GetbannerImages, false), Settings.AccessTokenSettings);
//var _response = await _apicall.GetResponse<BannerResponse>();
//if (_response != null)
//{
// if (_response.subOneBanner != null)
// {
// if (_response.subOneBanner.Count > 0)
// {
// foreach (var item in _response.subOneBanner.ToList())
// {
// subonecount++;
// if (subonecount < 8)
// {
// string filepath = AppSetting.Root_Url + item.ImageData;
// SubBannerOneImages _bannerImg = new SubBannerOneImages();
// _bannerImg.ImageId = item.ImageId;
// _bannerImg.SubOneImage = filepath;
// _bannerImg.SubOneImagelabel = string.IsNullOrEmpty(item.Description) ? "" : item.Description;
// //var imageBytes = Convert.FromBase64String(item.ImageData);
// //_bannerImg.Image = ImageSource.FromStream(() => new MemoryStream(imageBytes));
// SubOneBannerImagesList.Add(_bannerImg);
// }
// }
// }
// else
// {
// SubBannerOneImages _bannerImg = new SubBannerOneImages();
// string imagePath = AppSetting.Root_Url + "Portals/0/UrbanService/Images/banner.png";
// _bannerImg.SubOneImage = imagePath;// "banner.png";
// _bannerImg.SubOneImagelabel = "Banner Image";
// SubOneBannerImagesList.Add(_bannerImg);
// }
// }
// else
// {
// SubBannerOneImages _bannerImg = new SubBannerOneImages();
// string imagePath = AppSetting.Root_Url + "Portals/0/UrbanService/Images/banner.png";
// _bannerImg.SubOneImage = imagePath;// "banner.png";
// _bannerImg.SubOneImagelabel = "Banner Image";
// SubOneBannerImagesList.Add(_bannerImg);
// }
// if (_response.subTwoBanner != null)
// {
// if (_response.subTwoBanner.Count > 0)
// {
// foreach (var item in _response.subTwoBanner.ToList())
// {
// subtwocount++;
// if (subtwocount < 8)
// {
// string filepath = AppSetting.Root_Url + item.ImageData;
// SubBannerTwoImages _bannerImg = new SubBannerTwoImages();
// _bannerImg.ImageId = item.ImageId;
// _bannerImg.SubTwoImage = filepath;
// _bannerImg.SubTwoImagelabel = string.IsNullOrEmpty(item.Description) ? "" : item.Description;
// //var imageBytes = Convert.FromBase64String(item.ImageData);
// //_bannerImg.Image = ImageSource.FromStream(() => new MemoryStream(imageBytes));
// SubTwoBannerImagesList.Add(_bannerImg);
// }
// }
// }
// else
// {
// SubBannerTwoImages _bannerImg = new SubBannerTwoImages();
// string imagePath = AppSetting.Root_Url + "Portals/0/UrbanService/Images/banner.png";
// _bannerImg.SubTwoImage = imagePath;// "banner.png";
// _bannerImg.SubTwoImagelabel = "Banner Image";
// SubTwoBannerImagesList.Add(_bannerImg);
// }
// }
// else
// {
// SubBannerTwoImages _bannerImg = new SubBannerTwoImages();
// string imagePath = AppSetting.Root_Url + "Portals/0/UrbanService/Images/banner.png";
// _bannerImg.SubTwoImage = imagePath;// "banner.png";
// _bannerImg.SubTwoImagelabel = "Banner Image";
// SubTwoBannerImagesList.Add(_bannerImg);
// SubBannerOneImages bannerImg = new SubBannerOneImages();
// string _imagePath = AppSetting.Root_Url + "Portals/0/UrbanService/Images/banner.png";
// bannerImg.SubOneImage = _imagePath;// "banner.png";
// bannerImg.SubOneImagelabel = "Banner Image";
// SubOneBannerImagesList.Add(bannerImg);
// }
//}
//else
//{
// SubBannerTwoImages _bannerImg = new SubBannerTwoImages();
// string imagePath = AppSetting.Root_Url + "Portals/0/UrbanService/Images/banner.png";
// _bannerImg.SubTwoImage = imagePath;// "banner.png";
// _bannerImg.SubTwoImagelabel = "Banner Image";
// SubTwoBannerImagesList.Add(_bannerImg);
// SubBannerOneImages bannerImg = new SubBannerOneImages();
// string _imagePath = AppSetting.Root_Url + "Portals/0/UrbanService/Images/banner.png";
// bannerImg.SubOneImage = _imagePath;// "banner.png";
// bannerImg.SubOneImagelabel = "Banner Image";
// SubOneBannerImagesList.Add(bannerImg);
//}
//SubOneBannerImgs = new ReadOnlyObservableCollection<SubBannerOneImages>(SubOneBannerImagesList);
//SubTwoBannerImgs = new ReadOnlyObservableCollection<SubBannerTwoImages>(SubTwoBannerImagesList);
//UserDialogs.Instance.HideLoading();
}
else
{
UserDialogs.Instance.HideLoading();
await Application.Current.MainPage.DisplayAlert("Network", AppConstant.NETWORK_FAILURE, "OK");
return;
}
}
catch (Exception ex)
{
UserDialogs.Instance.HideLoading();
}
}
/// <summary>
/// Given a collection, index and item to remove, will try to remove that item
/// from the index. If the item has duplicates, will verify that only the first
/// instance was removed.
/// </summary>
public void RemoveItemTest(ReadOnlyObservableCollection <string> readOnlyCol, ObservableCollection <string> collection,
int itemIndex, string itemToRemove, bool isSuccessfulRemove, bool hasDuplicates)
{
INotifyPropertyChanged readOnlyPropertyChanged = readOnlyCol;
readOnlyPropertyChanged.PropertyChanged += Collection_PropertyChanged;
_expectedPropertyChanged = new[]
{
new PropertyNameExpected(COUNT),
new PropertyNameExpected(ITEMARRAY)
};
INotifyCollectionChanged readOnlyCollectionChange = readOnlyCol;
readOnlyCollectionChange.CollectionChanged += Collection_CollectionChanged;
if (isSuccessfulRemove)
{
_expectedCollectionChangedFired++;
}
_expectedAction = NotifyCollectionChangedAction.Remove;
_expectedNewItems = null;
_expectedNewStartingIndex = -1;
_expectedOldItems = new string[] { itemToRemove };
_expectedOldStartingIndex = itemIndex;
int expectedCount = isSuccessfulRemove ? collection.Count - 1 : collection.Count;
bool removedItem = collection.Remove(itemToRemove);
Assert.Equal(expectedCount, readOnlyCol.Count);
Assert.Equal(_expectedCollectionChangedFired, _numCollectionChangedFired);
if (isSuccessfulRemove)
{
foreach (var item in _expectedPropertyChanged)
{
Assert.True(item.IsFound, "The propertychanged event should have fired for" + item.Name + ", since an item was removed");
}
Assert.True(removedItem, "Should have been successful in removing the item.");
}
else
{
foreach (var item in _expectedPropertyChanged)
{
Assert.False(item.IsFound, "The propertychanged event should have fired for" + item.Name + ", since no items were removed.");
}
Assert.False(removedItem, "Should not have been successful in removing the item.");
}
if (hasDuplicates)
{
return;
}
Assert.DoesNotContain(itemToRemove, collection);
readOnlyCollectionChange.CollectionChanged -= Collection_CollectionChanged;
readOnlyPropertyChanged.PropertyChanged -= Collection_PropertyChanged;
}
public FFmpegLog()
{
LogItems = new ReadOnlyObservableCollection <FFmpegLogItem>(_logItems);
}
/// <summary>
/// Creates a <see cref="MaxTracker{TValue}"/> for <paramref name="source"/>
/// </summary>
/// <typeparam name="TValue">The type of the max value.</typeparam>
/// <param name="source">The source collection.</param>
/// <returns>A tracker with Value synced with source.Max()</returns>
public static MaxTracker <TValue> TrackMax <TValue>(this ReadOnlyObservableCollection <TValue> source)
where TValue : struct, IComparable <TValue>
{
return(new MaxTracker <TValue>(new SimpleChanges <ReadOnlyObservableCollection <TValue>, TValue>(source)));
}
/// <summary>
/// Creates a <see cref="MaxTracker{TValue}"/> for <paramref name="source"/>
/// </summary>
/// <typeparam name="TItem">The type of the items in <paramref name="source"/></typeparam>
/// <typeparam name="TValue">The type of the max value.</typeparam>
/// <param name="source">The source collection.</param>
/// <param name="selector">The function used when producing a value from an item.</param>
/// <returns>A tracker with Value synced with source.Max()</returns>
public static MaxTracker <TValue> TrackMax <TItem, TValue>(this ReadOnlyObservableCollection <TItem> source, Expression <Func <TItem, TValue> > selector)
where TItem : class, INotifyPropertyChanged
where TValue : struct, IComparable <TValue>
{
return(new MaxTracker <TValue>(new NestedChanges <ReadOnlyObservableCollection <TItem>, TItem, TValue>(source, selector)));
}
public Model()
{
StudentItems = new ReadOnlyObservableCollection <string>(_studentItems);
GroupItems = new ReadOnlyObservableCollection <string>(_groupItems);
}
public MenuViewModel(MenuDefinition definition)
{
this.definition = definition ?? throw new ArgumentNullException(nameof(definition));
items = definition.Items.ToReadOnlyObservableCollectionOf(d => d.Build());
}
public MenuViewModel()
{
this.definition = CreateDefinition();
items = definition.Items.ToReadOnlyObservableCollectionOf(d => d.Build());
}
public Parent(int id)
{
Id = id;
Children = new ObservableCollection <Person>();
ChildrenReadonly = new ReadOnlyObservableCollection <Person>(Children);
}
public IssueDialogViewModel()
{
Items = new ReadOnlyObservableCollection <ItemViewModel>(_items);
AddDummyItems(3);
}
public static int BinarySearch(this ReadOnlyObservableCollection <ILogItem> Collection, ILogItem Item, ItemNotFoundBehavior ItemNotFoundBehavior = ItemNotFoundBehavior.ReturnMinusOne)
{
return(BinarySearch(Collection, Item, 0, Collection.Count - 1, ItemNotFoundBehavior));
}
public RootPage()
{
Children = new ReadOnlyObservableCollection <IWizardPage>(pages);
}
private void LoadCharacters(bool blnRefreshFavorites = true, bool blnRefreshRecents = true, bool blnRefreshWatch = true)
{
ReadOnlyObservableCollection <string> lstFavorites = new ReadOnlyObservableCollection <string>(GlobalOptions.FavoritedCharacters);
bool blnAddFavouriteNode = false;
TreeNode objFavouriteNode = null;
TreeNode[] lstFavoritesNodes = null;
if (blnRefreshFavorites)
{
objFavouriteNode = treCharacterList.FindNode("Favourite", false);
if (objFavouriteNode == null)
{
objFavouriteNode = new TreeNode(LanguageManager.GetString("Treenode_Roster_FavouriteCharacters", GlobalOptions.Language))
{
Tag = "Favourite"
};
blnAddFavouriteNode = true;
}
lstFavoritesNodes = new TreeNode[lstFavorites.Count];
}
IList <string> lstRecents = new List <string>(GlobalOptions.MostRecentlyUsedCharacters);
List <string> lstWatch = new List <string>();
if (!string.IsNullOrEmpty(GlobalOptions.CharacterRosterPath) && Directory.Exists(GlobalOptions.CharacterRosterPath))
{
string[] objFiles = Directory.GetFiles(GlobalOptions.CharacterRosterPath, "*.chum5");
for (int i = 0; i < objFiles.Length; ++i)
{
string strFile = objFiles[i];
// Make sure we're not loading a character that was already loaded by the MRU list.
if (lstFavorites.Contains(strFile) ||
lstRecents.Contains(strFile))
{
continue;
}
lstWatch.Add(strFile);
}
}
bool blnAddWatchNode = false;
TreeNode objWatchNode = null;
TreeNode[] lstWatchNodes = null;
if (blnRefreshWatch)
{
objWatchNode = treCharacterList.FindNode("Watch", false);
if (objWatchNode == null && lstWatch.Count > 0)
{
objWatchNode = new TreeNode(LanguageManager.GetString("Treenode_Roster_WatchFolder", GlobalOptions.Language))
{
Tag = "Watch"
};
blnAddWatchNode = true;
}
lstWatchNodes = new TreeNode[lstWatch.Count];
}
bool blnAddRecentNode = false;
TreeNode objRecentNode = null;
TreeNode[] lstRecentsNodes = null;
if (blnRefreshRecents)
{
// Add any characters that are open to the displayed list so we can have more than 10 characters listed
foreach (CharacterShared objCharacterForm in Program.MainForm.OpenCharacterForms)
{
string strFile = objCharacterForm.CharacterObject.FileName;
// Make sure we're not loading a character that was already loaded by the MRU list.
if (lstFavorites.Contains(strFile) ||
lstRecents.Contains(strFile) ||
lstWatch.Contains(strFile))
{
continue;
}
lstRecents.Add(strFile);
}
foreach (string strFavorite in lstFavorites)
{
lstRecents.Remove(strFavorite);
}
objRecentNode = treCharacterList.FindNode("Recent", false);
if (objRecentNode == null && lstRecents.Count > 0)
{
objRecentNode = new TreeNode(LanguageManager.GetString("Treenode_Roster_RecentCharacters", GlobalOptions.Language))
{
Tag = "Recent"
};
blnAddRecentNode = true;
}
lstRecentsNodes = new TreeNode[lstRecents.Count];
}
Parallel.Invoke(
() => {
if (objFavouriteNode != null && lstFavoritesNodes != null)
{
object lstFavoritesNodesLock = new object();
Parallel.For(0, lstFavorites.Count, i =>
{
string strFile = lstFavorites[i];
TreeNode objNode = CacheCharacter(strFile);
lock (lstFavoritesNodesLock)
lstFavoritesNodes[i] = objNode;
});
if (blnAddFavouriteNode)
{
for (int i = 0; i < lstFavoritesNodes.Length; i++)
{
TreeNode objNode = lstFavoritesNodes[i];
if (objNode != null)
{
objFavouriteNode.Nodes.Add(objNode);
}
}
}
}
},
() => {
if (objRecentNode != null && lstRecentsNodes != null)
{
object lstRecentsNodesLock = new object();
Parallel.For(0, lstRecents.Count, i =>
{
string strFile = lstRecents[i];
TreeNode objNode = CacheCharacter(strFile);
lock (lstRecentsNodesLock)
lstRecentsNodes[i] = objNode;
});
if (blnAddRecentNode)
{
for (int i = 0; i < lstRecentsNodes.Length; i++)
{
TreeNode objNode = lstRecentsNodes[i];
if (objNode != null)
{
objRecentNode.Nodes.Add(objNode);
}
}
}
}
},
() =>
{
if (objWatchNode != null && lstWatchNodes != null)
{
object lstWatchNodesLock = new object();
Parallel.For(0, lstWatch.Count, i =>
{
string strFile = lstWatch[i];
TreeNode objNode = CacheCharacter(strFile);
lock (lstWatchNodesLock)
lstWatchNodes[i] = objNode;
});
if (blnAddWatchNode)
{
for (int i = 0; i < lstWatchNodes.Length; i++)
{
TreeNode objNode = lstWatchNodes[i];
if (objNode != null)
{
objWatchNode.Nodes.Add(objNode);
}
}
}
}
});
if (objFavouriteNode != null)
{
if (blnAddFavouriteNode)
{
treCharacterList.Nodes.Add(objFavouriteNode);
objFavouriteNode.Expand();
}
else
{
objFavouriteNode.Nodes.Clear();
for (int i = 0; i < lstFavoritesNodes.Length; i++)
{
TreeNode objNode = lstFavoritesNodes[i];
if (objNode != null)
{
objFavouriteNode.Nodes.Add(objNode);
}
}
}
}
if (objRecentNode != null)
{
if (blnAddRecentNode)
{
treCharacterList.Nodes.Add(objRecentNode);
objRecentNode.Expand();
}
else
{
objRecentNode.Nodes.Clear();
for (int i = 0; i < lstRecentsNodes.Length; i++)
{
TreeNode objNode = lstRecentsNodes[i];
if (objNode != null)
{
objRecentNode.Nodes.Add(objNode);
}
}
}
}
if (objWatchNode != null)
{
if (blnAddWatchNode)
{
treCharacterList.Nodes.Add(objWatchNode);
objWatchNode.Expand();
}
else
{
objWatchNode.Nodes.Clear();
for (int i = 0; i < lstWatchNodes.Length; i++)
{
TreeNode objNode = lstWatchNodes[i];
if (objNode != null)
{
objWatchNode.Nodes.Add(objNode);
}
}
}
}
treCharacterList.ExpandAll();
}
/// <summary>
/// Initializes a new instance of the <see cref="MappingView{TSource, TResult}"/> class.
/// </summary>
public MappingView(ReadOnlyObservableCollection <TSource> source, Func <TSource, int, TResult> selector, Func <TResult, int, TResult> updater, TimeSpan bufferTime, IScheduler scheduler = null, bool leaveOpen = false, params IObservable <object>[] triggers)
: this((IEnumerable <TSource>)source, Mapper.Create(selector, updater), bufferTime, scheduler, leaveOpen, triggers)
{
}
public void LoadCharacters(bool blnRefreshFavorites = true, bool blnRefreshRecents = true, bool blnRefreshWatch = true, bool blnRefreshPlugins = true)
{
_blnSkipUpdate = true;
ReadOnlyObservableCollection <string> lstFavorites = new ReadOnlyObservableCollection <string>(GlobalOptions.FavoritedCharacters);
bool blnAddFavoriteNode = false;
TreeNode objFavoriteNode = null;
TreeNode[] lstFavoritesNodes = null;
if (blnRefreshFavorites)
{
objFavoriteNode = treCharacterList.FindNode("Favorite", false);
if (objFavoriteNode == null)
{
objFavoriteNode = new TreeNode(LanguageManager.GetString("Treenode_Roster_FavoriteCharacters"))
{
Tag = "Favorite"
};
blnAddFavoriteNode = true;
}
lstFavoritesNodes = new TreeNode[lstFavorites.Count];
}
List <string> lstRecents = new List <string>(GlobalOptions.MostRecentlyUsedCharacters);
Dictionary <string, string> dicWatch = new Dictionary <string, string>();
int intWatchFolderCount = 0;
if (!string.IsNullOrEmpty(GlobalOptions.CharacterRosterPath) && Directory.Exists(GlobalOptions.CharacterRosterPath))
{
intWatchFolderCount++;
foreach (string strFile in Directory.GetFiles(GlobalOptions.CharacterRosterPath, "*.chum5", SearchOption.AllDirectories))
{
// Make sure we're not loading a character that was already loaded by the MRU list.
if (lstFavorites.Contains(strFile) ||
lstRecents.Contains(strFile))
{
continue;
}
FileInfo objInfo = new FileInfo(strFile);
if (objInfo.Directory == null || objInfo.Directory.FullName == GlobalOptions.CharacterRosterPath)
{
dicWatch.Add(strFile, "Watch");
continue;
}
string strNewParent = objInfo.Directory.FullName.Replace(GlobalOptions.CharacterRosterPath + "\\", string.Empty);
dicWatch.Add(strFile, strNewParent);
}
intWatchFolderCount++;
}
bool blnAddWatchNode = false;
TreeNode objWatchNode = null;
TreeNode[] lstWatchNodes = null;
if (blnRefreshWatch)
{
objWatchNode = treCharacterList.FindNode("Watch", false);
objWatchNode?.Remove();
blnAddWatchNode = dicWatch.Count > 0;
if (blnAddWatchNode)
{
objWatchNode = new TreeNode(LanguageManager.GetString("Treenode_Roster_WatchFolder"))
{
Tag = "Watch"
};
}
lstWatchNodes = new TreeNode[intWatchFolderCount];
}
bool blnAddRecentNode = false;
TreeNode objRecentNode = null;
TreeNode[] lstRecentsNodes = null;
if (blnRefreshRecents)
{
// Add any characters that are open to the displayed list so we can have more than 10 characters listed
foreach (CharacterShared objCharacterForm in Program.MainForm.OpenCharacterForms)
{
string strFile = objCharacterForm.CharacterObject.FileName;
// Make sure we're not loading a character that was already loaded by the MRU list.
if (lstFavorites.Contains(strFile) ||
lstRecents.Contains(strFile) ||
dicWatch.ContainsValue(strFile))
{
continue;
}
lstRecents.Add(strFile);
}
foreach (string strFavorite in lstFavorites)
{
lstRecents.Remove(strFavorite);
}
objRecentNode = treCharacterList.FindNode("Recent", false);
if (objRecentNode == null && lstRecents.Count > 0)
{
objRecentNode = new TreeNode(LanguageManager.GetString("Treenode_Roster_RecentCharacters"))
{
Tag = "Recent"
};
blnAddRecentNode = true;
}
lstRecentsNodes = new TreeNode[lstRecents.Count];
}
Parallel.Invoke(
() =>
{
if (lstFavoritesNodes == null || lstFavorites.Count <= 0)
{
return;
}
Parallel.For(0, lstFavorites.Count, i => lstFavoritesNodes[i] = CacheCharacter(lstFavorites[i]));
if (blnAddFavoriteNode && objFavoriteNode != null)
{
foreach (TreeNode objNode in lstFavoritesNodes)
{
if (objNode != null)
{
objFavoriteNode.Nodes.Add(objNode);
}
}
}
},
() =>
{
if (lstRecentsNodes == null || lstRecents.Count <= 0)
{
return;
}
Parallel.For(0, lstRecents.Count, i => lstRecentsNodes[i] = CacheCharacter(lstRecents[i]));
if (blnAddRecentNode && objRecentNode != null)
{
foreach (TreeNode objNode in lstRecentsNodes)
{
if (objNode != null)
{
objRecentNode.Nodes.Add(objNode);
}
}
}
},
() =>
{
if (objWatchNode == null || !blnAddWatchNode || dicWatch.Count <= 0)
{
return;
}
ConcurrentDictionary <TreeNode, string> dicWatchNodes = new ConcurrentDictionary <TreeNode, string>();
Parallel.ForEach(dicWatch, kvpLoop => dicWatchNodes.TryAdd(CacheCharacter(kvpLoop.Key), kvpLoop.Value));
foreach (string s in dicWatchNodes.Values.Distinct())
{
if (s == "Watch")
{
continue;
}
objWatchNode.Nodes.Add(new TreeNode(s)
{
Tag = s
});
}
foreach (KeyValuePair <TreeNode, string> kvtNode in dicWatchNodes)
{
if (kvtNode.Value == "Watch")
{
objWatchNode.Nodes.Add(kvtNode.Key);
}
else
{
foreach (TreeNode objNode in objWatchNode.Nodes)
{
if (objNode.Tag.ToString() == kvtNode.Value)
{
objNode.Nodes.Add(kvtNode.Key);
}
}
}
}
},
async() =>
{
foreach (IPlugin plugin in Program.PluginLoader.MyActivePlugins)
{
List <TreeNode> lstNodes = await Task.Run(async() =>
{
Log.Info("Starting new Task to get CharacterRosterTreeNodes for plugin:" + plugin);
ICollection <TreeNode> lstTreeNodes = await plugin.GetCharacterRosterTreeNode(this, blnRefreshPlugins);
return(lstTreeNodes?.OrderBy(a => a.Text).ToList() ?? new List <TreeNode>());
});
await Task.Run(() =>
{
foreach (TreeNode node in lstNodes)
{
TreeNode objExistingNode = treCharacterList.Nodes.Cast <TreeNode>().FirstOrDefault(x => x.Text == node.Text && x.Tag == node.Tag);
Program.MainForm.DoThreadSafe(() =>
{
try
{
if (objExistingNode != null)
{
treCharacterList.DoThreadSafe(() => treCharacterList.Nodes.Remove(objExistingNode));
}
if (node.Nodes.Count > 0 || !string.IsNullOrEmpty(node.ToolTipText) ||
node.Tag != null)
{
if (treCharacterList.IsNullOrDisposed())
{
return;
}
treCharacterList.DoThreadSafe(() =>
{
if (treCharacterList.Nodes.ContainsKey(node.Name))
{
treCharacterList.Nodes.RemoveByKey(node.Name);
}
treCharacterList.Nodes.Insert(1, node);
});
}
node.Expand();
}
catch (ObjectDisposedException e)
{
Log.Trace(e);
}
catch (InvalidAsynchronousStateException e)
{
Log.Trace(e);
}
catch (ArgumentException e)
{
Log.Trace(e);
}
catch (Exception e)
{
Log.Warn(e);
}
});
}
Log.Info("Task to get and add CharacterRosterTreeNodes for plugin " + plugin + " finished.");
});
}
});
Log.Info("Populating CharacterRosterTreeNode (MainThread).");
treCharacterList.SuspendLayout();
if (objFavoriteNode != null)
{
if (blnAddFavoriteNode)
{
treCharacterList.Nodes.Add(objFavoriteNode);
objFavoriteNode.Expand();
}
else
{
objFavoriteNode.Nodes.Clear();
foreach (TreeNode objNode in lstFavoritesNodes)
{
if (objNode != null)
{
objFavoriteNode.Nodes.Add(objNode);
}
}
}
}
if (objRecentNode != null)
{
if (blnAddRecentNode)
{
treCharacterList.Nodes.Add(objRecentNode);
objRecentNode.Expand();
}
else
{
try
{
objRecentNode.Nodes.Clear();
foreach (TreeNode objNode in lstRecentsNodes)
{
if (objNode != null)
{
objRecentNode.Nodes.Add(objNode);
}
}
}
catch (ObjectDisposedException e)
{
//just swallow this
Log.Trace(e, "ObjectDisposedException can be ignored here.");
}
}
}
if (objWatchNode != null)
{
if (blnAddWatchNode)
{
treCharacterList.Nodes.Add(objWatchNode);
objWatchNode.Expand();
}
else
{
objWatchNode.Nodes.Clear();
foreach (TreeNode objNode in lstWatchNodes)
{
if (objNode != null)
{
objWatchNode.Nodes.Add(objNode);
}
}
}
}
treCharacterList.ExpandAll();
treCharacterList.ResumeLayout();
UpdateCharacter(treCharacterList.SelectedNode?.Tag as CharacterCache);
_blnSkipUpdate = false;
}
public static INotifyCollectionChanged AsINPC <T>(this ReadOnlyObservableCollection <T> source)
{
Contract.Requires(source != null);
return((INotifyCollectionChanged)source);
}
public SourceFilter()
{
sourceFilters = new ObservableCollection <SourceFilterItem>();
SourceFilters = new ReadOnlyObservableCollection <SourceFilterItem>(sourceFilters);
}
public MarbleDiagramScreenViewModel(IConcurrencyService concurrencyService)
{
var itemGroups = new ObservableCollectionExtended <MarbleObservableItemGroup>();
ObservableItemGroups = new ReadOnlyObservableCollection <MarbleObservableItemGroup>(itemGroups);
this.WhenActivated(disposables =>
{
itemGroups.Clear();
var instances = ObservableInstances
.TakeUntilDisposed(disposables)
.Publish();
var observableItems = instances
.Transform(obs => Observable.Return(new MarbleObservableItem(concurrencyService)
{
ObservableInstance = obs
})
.Expand(item => item.ObservableInstance.Inputs.Select(input => new MarbleObservableItem(concurrencyService)
{
ObservableInstance = input, PrimarySink = item
}))
.ToObservableChangeSet(obs => obs.ObservableInstance.ObservableId))
.RemoveKey()
.AsObservableList()
.Or();
var observableItemsGroupedByCall = observableItems
.Group(item => item.ObservableInstance.Call.InstrumentedCallId)
.Transform(group =>
{
var firstItem = group.Cache.Items.First();
var observableItemsInGroup = new ObservableCollectionExtended <MarbleObservableItem>();
group.Cache.Connect()
.OnItemAdded(obsItem => obsItem.Activator.Activate().DisposeWith(disposables))
.Sort(Utility.Comparer <MarbleObservableItem> .ByKey(x => x.GetOrdering(), EnumerableComparer <long> .LongerBeforeShorter))
.SubscribeOn(concurrencyService.TaskPoolRxScheduler)
.ObserveOn(concurrencyService.DispatcherRxScheduler)
.Bind(observableItemsInGroup)
.Subscribe()
.DisposeWith(disposables);
return(new MarbleObservableItemGroup(firstItem.GetOrdering(), firstItem.ObservableInstance.Call, new ReadOnlyObservableCollection <MarbleObservableItem>(observableItemsInGroup), concurrencyService));
});
observableItemsGroupedByCall
.Sort(Utility.Comparer <MarbleObservableItemGroup> .ByKey(x => x.Ordering, EnumerableComparer <long> .LongerBeforeShorter))
.SubscribeOn(concurrencyService.TaskPoolRxScheduler)
.ObserveOn(concurrencyService.DispatcherRxScheduler)
.Bind(itemGroups)
.Subscribe()
.DisposeWith(disposables);
instances
.Minimum(obs => obs.Created.Timestamp.Ticks)
.DistinctUntilChanged()
.Select(ticks => new DateTime(ticks, DateTimeKind.Utc))
.SubscribeOn(concurrencyService.TaskPoolRxScheduler)
.ObserveOn(concurrencyService.DispatcherRxScheduler)
.ToProperty(this, x => x.StartTime, out mStartTime)
.DisposeWith(disposables);
instances.Connect();
});
}
public ActionsDatabase()
{
_actions = new ObservableCollection <ActionEntry>();
Actions = new ReadOnlyObservableCollection <ActionEntry>(_actions);
}
static Logger()
{
LogItems = new ReadOnlyObservableCollection <LogItem>(logItems);
}
public QueryResultVm()
{
TreeNodes = new ReadOnlyObservableCollection<CodeTree>(_pointcuts);
}
protected AudioSource()
{
AvailableRecordingSources = new ReadOnlyObservableCollection <IAudioItem>(RecordingSources);
AvailableLoopbackSources = new ReadOnlyObservableCollection <IAudioItem>(LoopbackSources);
}
public ObservableCollectionPlus(IEnumerable <T> collection)
: base(collection)
{
m_roCollection = new ReadOnlyObservableCollection <T>(this);
m_lock = new WrappedLock(BeforeMultiUpdate, finishMultiUpdate);
}
public ObservableSoundService()
{
_activeSounds = new ObservableCollection <ISound>();
ActiveSounds = new ReadOnlyObservableCollection <ISound>(_activeSounds);
}
public TypeLibraries()
{
_libraries = new ObservableCollection <TypeLibrary>();
LoadedLibraries = new ReadOnlyObservableCollection <TypeLibrary>(_libraries);
}
public SaveDataSlotSelectorViewModel()
{
Accounts = new ReadOnlyObservableCollection <SaveDataAccountViewModel <T> >(accounts);
}
private void MediaCharactersChanged(object sender, NotifyCollectionChangedEventArgs e)
{
if (e.NewItems != null)
{
foreach (MediaCharacter character in e.NewItems)
{
foreach (MediaTag tag in character.Tags)
{
if (!_allCharacterTags.Contains(tag.Text))
{
_allCharacterTags.Add(tag.Text);
}
}
if (!_allCharacterNames.Contains(character.Name))
{
_allCharacterNames.Add(character.Name);
}
((INotifyCollectionChanged)character.Tags).CollectionChanged += MediaCharacterTagsChanged;
}
}
if (e.OldItems != null)
{
foreach (MediaCharacter oldCharacter in e.OldItems)
{
ReadOnlyObservableCollection <MediaTag> oldTags = oldCharacter.Tags;
bool removeCharacterName = true;
foreach (MediaCollection collection in _mediaCollections)
{
foreach (Media media in collection.Media)
{
foreach (MediaCharacter character in media.Metadata.Characters)
{
if (character.Name == oldCharacter.Name)
{
removeCharacterName = false;
}
}
}
}
foreach (MediaTag oldTag in oldTags)
{
bool removeTag = true;
foreach (MediaCollection collection in _mediaCollections)
{
foreach (Media media in collection.Media)
{
foreach (MediaCharacter character in media.Metadata.Characters)
{
if (character.Name == oldCharacter.Name)
{
removeCharacterName = false;
}
foreach (MediaTag tag in character.Tags)
{
if (tag.Text == oldTag.Text)
{
removeTag = false;
}
}
}
}
}
if (removeTag)
{
_allCharacterTags.Remove(oldTag.Text);
}
}
if (removeCharacterName)
{
_allCharacterNames.Remove(oldCharacter.Name);
}
}
}
}
public Parent(int id, IEnumerable <Person> children)
{
Id = id;
Children = new ObservableCollection <Person>(children);
ChildrenReadonly = new ReadOnlyObservableCollection <Person>(Children);
}
public RecentViewModel(Settings Settings,
IRecentList Recent)
: base(Settings)
{
Items = Recent.Items;
}
static MastodonAuthenticationHouse()
{
Authes = new ReadOnlyObservableCollection <MastodonAuthentication>(_authes);
}
