public VisualScriptEditorViewModel(IVisualScriptViewModelService visualScriptViewModelService, VisualScriptViewModel visualScript) : base(visualScript) { // Create the service needed to manage observable view models ViewModelService = new GraphViewModelService(Session.AssetNodeContainer); // Update the service provider of this view model to contains the ObservableViewModelService we created. ServiceProvider = new ViewModelServiceProvider(ServiceProvider, ViewModelService.Yield()); VisualScriptViewModelService = visualScriptViewModelService; blockTemplateDescriptionCollection = new Lazy <BlockTemplateDescriptionCollectionViewModel>(() => new BlockTemplateDescriptionCollectionViewModel(this)); AddNewPropertyCommand = new AnonymousCommand(ServiceProvider, AddNewProperty); RemoveSelectedPropertiesCommand = new AnonymousCommand(ServiceProvider, RemoveSelectedProperties); //ShowAddBlockDialogCommand = new AnonymousTaskCommand(ServiceProvider, ShowAddBlockDialog); AddNewMethodCommand = new AnonymousCommand(ServiceProvider, AddNewMethod); RemoveSelectedMethodCommand = new AnonymousCommand(ServiceProvider, RemoveSelectedFunction); var rootNode = Session.AssetNodeContainer.GetNode(visualScript.Asset); baseTypeNodeBinding = new MemberGraphNodeBinding <string>(rootNode[nameof(VisualScriptAsset.BaseType)], nameof(BaseType), OnPropertyChanging, OnPropertyChanged, visualScript.UndoRedoService); propertiesNode = rootNode[nameof(VisualScriptAsset.Properties)]; }
public GameStudioWindow(EditorViewModel editor) { if (editor == null) { throw new ArgumentNullException(nameof(editor)); } if (editor.Session == null) { throw new ArgumentException($@"A valid session must exist before creating a {nameof(GameStudioWindow)}", nameof(editor)); } DataContext = editor; // Must be set before calling InitializeComponent dockingLayout = new DockingLayoutManager(this, editor.Session); assetEditorsManager = new AssetEditorsManager(dockingLayout, editor.Session); editor.ServiceProvider.Get <IEditorDialogService>().AssetEditorsManager = assetEditorsManager; OpenDebugWindowCommand = new AnonymousCommand(editor.ServiceProvider, OpenDebugWindow); CreateTestAssetCommand = new AnonymousCommand(editor.ServiceProvider, CreateTestAsset); CreateUnitTestAssetCommand = new AnonymousCommand(editor.ServiceProvider, CreateUnitTestAsset); BreakDebuggerCommand = new AnonymousCommand(editor.ServiceProvider, BreakDebugger); EditorSettings.ResetEditorLayout.Command = new AnonymousTaskCommand(editor.ServiceProvider, ResetAllLayouts); InitializeComponent(); Application.Current.Activated += (s, e) => editor.ServiceProvider.Get <IEditorDialogService>().ShowDelayedNotifications(); Loaded += GameStudioLoaded; OpenMetricsProjectSession(editor); }
private static ThumbnailData FolderThumbnail;// = new Lazy<ThumbnailData>(GetFolderThumbnail, LazyThreadSafetyMode.PublicationOnly); /// <summary> /// Initializes a new instance of the <see cref="DirectoryViewModel"/> class with a parent directory. /// </summary> /// <param name="name">The name of this directory. Cannot be <c>null</c>.</param> /// <param name="parent">The parent of this directory. Cannot be <c>null</c>.</param> /// <param name="canUndoRedoCreation">Indicates if the creation of this view model should create a transaction in the undo/redo service.</param> public DirectoryViewModel(string name, DirectoryBaseViewModel parent, bool canUndoRedoCreation) : base(parent.SafeArgument(nameof(parent)).Package) { if (name == null) { throw new ArgumentNullException(nameof(name)); } string errorMessage; this.name = name; // Update property to make the directory dirty. The name must be already set here! if (canUndoRedoCreation) { Parent = parent; } else { this.parent = parent; SetParent(null, parent); } if (!IsValidName(name, out errorMessage)) { throw new ArgumentException(errorMessage); } RenameCommand = new AnonymousCommand(ServiceProvider, () => IsEditing = true); }
/// <summary> /// Initializes a new instance of the <see cref="EntityHierarchyEditorViewModel"/> class. /// </summary> /// <param name="asset">The asset related to this editor.</param> /// <param name="controllerFactory">A factory to create the associated <see cref="IEditorGameController"/>.</param> protected EntityHierarchyEditorViewModel([NotNull] EntityHierarchyViewModel asset, [NotNull] Func <GameEditorViewModel, IEditorGameController> controllerFactory) : base(asset, controllerFactory) { Controller.Loader.AssetLoading += (s, e) => asset.Dispatcher.InvokeAsync(() => CompilingAssets = e.ContentLoadingCount > 0); Controller.Loader.AssetLoaded += (s, e) => asset.Dispatcher.InvokeAsync(() => CompilingAssets = e.ContentLoadingCount > 0); Camera = new EditorCameraViewModel(ServiceProvider, Controller); Transform = new EntityTransformationViewModel(ServiceProvider, Controller); Grid = new EditorGridViewModel(ServiceProvider, Controller); Navigation = new EditorNavigationViewModel(ServiceProvider, Controller, this); Lighting = new EditorLightingViewModel(ServiceProvider, Controller, this); Rendering = new EditorRenderingViewModel(ServiceProvider, Controller); EntityGizmos = new EntityGizmosViewModel(ServiceProvider, Controller); CreateEntityCommand = new AnonymousTaskCommand <IEntityFactory>(ServiceProvider, x => CreateEntity(true, x, ActiveRoot ?? HierarchyRoot)); CreateEntityInRootCommand = new AnonymousTaskCommand <IEntityFactory>(ServiceProvider, x => CreateEntity(false, x, ActiveRoot ?? HierarchyRoot)); CreateFolderInRootCommand = new AnonymousCommand <IEntityFactory>(ServiceProvider, x => CreateFolder(HierarchyRoot.Asset, ActiveRoot ?? HierarchyRoot, true)); CreateEntityInSelectionCommand = new AnonymousTaskCommand <IEntityFactory>(ServiceProvider, x => CreateEntity(false, x, (EntityHierarchyItemViewModel)SelectedContent.FirstOrDefault() ?? ActiveRoot ?? HierarchyRoot)); CreateFolderInSelectionCommand = new AnonymousCommand <IEntityFactory>(ServiceProvider, x => { var element = (EntityHierarchyItemViewModel)SelectedContent.FirstOrDefault() ?? ActiveRoot ?? HierarchyRoot; CreateFolder(element.Asset, element, true); }); OpenPrefabEditorCommand = new AnonymousCommand(ServiceProvider, OpenPrefabEditor); SelectPrefabCommand = new AnonymousCommand(ServiceProvider, SelectPrefab); SetActiveRootCommand = new AnonymousCommand(ServiceProvider, SetActiveRoot); BreakLinkToPrefabCommand = new AnonymousCommand(ServiceProvider, BreakLinkToPrefab); CreatePrefabFromSelectionCommand = new AnonymousCommand(ServiceProvider, CreatePrefabFromSelection); UpdateCommands(); debugPage = new DebugEntityHierarchyEditorUserControl(this); EditorDebugTools.RegisterDebugPage(debugPage); }
public EntityFolderViewModel([NotNull] EntityHierarchyEditorViewModel editor, [NotNull] EntityHierarchyViewModel asset, string name, [NotNull] IEnumerable <EntityDesign> entities) : base(editor, asset, entities) { this.name = name; Id = new AbsoluteId(Asset.Id, Guid.NewGuid()); RenameCommand = new AnonymousCommand(ServiceProvider, () => IsEditing = true); }
protected EditorViewModel(IViewModelServiceProvider serviceProvider, MostRecentlyUsedFileCollection mru, string editorName) : base(serviceProvider) { AssetsPlugin.RegisterPlugin(typeof(AssetsEditorPlugin)); serviceProvider.Get <IEditorDialogService>(); ClearMRUCommand = new AnonymousCommand(serviceProvider, () => MRU.Clear()); OpenSettingsWindowCommand = new AnonymousCommand(serviceProvider, OpenSettingsWindow); OpenWebPageCommand = new AnonymousTaskCommand <string>(serviceProvider, OpenWebPage); #if DEBUG DebugCommand = new AnonymousCommand(serviceProvider, DebugFunction); #endif MRU = mru; MRU.MostRecentlyUsedFiles.CollectionChanged += MostRecentlyUsedFiles_CollectionChanged; UpdateRecentFiles(); serviceProvider.Get <IEditorDialogService>().RegisterDefaultTemplateProviders(); EditorName = editorName; if (Instance != null) { throw new InvalidOperationException("The EditorViewModel class can be instanced only once."); } Status = new StatusViewModel(ServiceProvider); Status.PushStatus("Ready"); Instance = this; }
public DebugEntityHierarchyEditorViewModel([NotNull] IViewModelServiceProvider serviceProvider, [NotNull] EntityHierarchyEditorViewModel editor) : base(serviceProvider) { this.editor = editor; var sceneLoader = editor.Controller.Loader; // We use reflection to access private fields and protected properties. var propertyInfo = typeof(EditorContentLoader).GetProperty("AssetLoadingTimeUrls", BindingFlags.Instance | BindingFlags.NonPublic); if (propertyInfo == null) { throw new MissingFieldException("EditorContentLoader misses the 'AssetLoadingTimeUrls' protected member."); } assetLoadingTimeUrls = (Dictionary <AssetId, string>)propertyInfo.GetValue(sceneLoader); propertyInfo = typeof(EditorContentLoader).GetProperty("Game", BindingFlags.Instance | BindingFlags.NonPublic); if (propertyInfo == null) { throw new MissingFieldException("EditorContentLoader misses the 'Game' protected member."); } game = (EditorServiceGame)propertyInfo.GetValue(sceneLoader); LoadingTimeUrls = new ObservableList <string>(); LoadedAssets = new ObservableList <string>(); RefreshCommand = new AnonymousCommand(ServiceProvider, Refresh); }
internal ReleaseNotesViewModel([NotNull] LauncherViewModel launcher, [NotNull] string version) : base(launcher.SafeArgument(nameof(launcher)).ServiceProvider) { if (version == null) { throw new ArgumentNullException(nameof(version)); } this.launcher = launcher; Version = version; baseUrl = $"{RootUrl}/{Version}/ReleaseNotes/"; #if DEBUG if (Environment.CommandLine.ToLowerInvariant().Contains("/previewreleasenotes")) { var launcherPath = AppDomain.CurrentDomain.BaseDirectory; var mdPath = Path.Combine(launcherPath, @"..\..\..\..\..\doc\"); if (File.Exists($"{mdPath}{ReleaseNotesFileName}")) { baseUrl = $"file:///{mdPath.Replace("\\", "/")}"; } } #endif ToggleCommand = new AnonymousCommand(ServiceProvider, Toggle); }
public GraphicsCompositorEditorViewModel([NotNull] GraphicsCompositorViewModel graphicsCompositor) : base(graphicsCompositor) { // Create the service needed to manage observable view models ViewModelService = new GraphViewModelService(Session.AssetNodeContainer); // Update the service provider of this view model to contains the ObservableViewModelService we created. ServiceProvider = new ViewModelServiceProvider(ServiceProvider, ViewModelService.Yield()); // Get some quantum nodes graphicsCompositorNode = Session.AssetNodeContainer.GetNode(graphicsCompositor.Asset); renderStagesNode = graphicsCompositorNode[nameof(GraphicsCompositorAsset.RenderStages)].Target; renderFeaturesNode = graphicsCompositorNode[nameof(GraphicsCompositorAsset.RenderFeatures)].Target; cameraSlotsNode = graphicsCompositorNode[nameof(GraphicsCompositorAsset.Cameras)].Target; sharedRenderersNode = graphicsCompositorNode[nameof(GraphicsCompositorAsset.SharedRenderers)].Target; // Setup commands DeleteSelectionCommand = new AnonymousCommand(ServiceProvider, DeleteSelection); AddNewRenderStageCommand = new AnonymousCommand(ServiceProvider, AddNewRenderStage); RemoveSelectedRenderStagesCommand = new AnonymousCommand(ServiceProvider, RemoveSelectedRenderStages); AddNewRenderFeatureCommand = new AnonymousCommand <AbstractNodeType>(ServiceProvider, AddNewRenderFeature); RemoveSelectedRenderFeaturesCommand = new AnonymousCommand(ServiceProvider, RemoveSelectedRenderFeatures); AddNewCameraSlotCommand = new AnonymousCommand(ServiceProvider, AddNewCameraSlot); RemoveSelectedCameraSlotsCommand = new AnonymousCommand(ServiceProvider, RemoveSelectedCameraSlots); }
public EquipmentViewModel(RootViewModel rootViewModel, IEquipment equipment) { this.rootViewModel = rootViewModel; this.Equipment = equipment; TogglePossessionCommand = new AnonymousCommand(_ => IsPossessed = !IsPossessed); }
/// <summary> /// Initializes a new instance of the <see cref="GameEditorViewModel"/> class. /// </summary> /// <param name="asset">The asset related to this editor.</param> /// <param name="controllerFactory">A factory to create the associated <see cref="IEditorGameController"/>.</param> protected GameEditorViewModel([NotNull] AssetViewModel asset, [NotNull] Func <GameEditorViewModel, IEditorGameController> controllerFactory) : base(asset) { Controller = controllerFactory(this); CopyErrorToClipboardCommand = new AnonymousCommand(ServiceProvider, CopyErrorToClipboard); ResumeCommand = new AnonymousCommand(ServiceProvider, ResumeFromError); }
/// <summary> /// Initializes a new instance of the <see cref="EditorNavigationViewModel"/> class. /// </summary> /// <param name="editor"></param> /// <param name="serviceProvider">The service provider for this view model.</param> /// <param name="controller">The controller object for the related editor game.</param> public EditorNavigationViewModel([NotNull] IViewModelServiceProvider serviceProvider, [NotNull] IEditorGameController controller, [NotNull] EntityHierarchyEditorViewModel editor) : base(serviceProvider) { if (controller == null) { throw new ArgumentNullException(nameof(controller)); } this.editor = editor; this.controller = controller; ToggleAllGroupsCommand = new AnonymousCommand <bool>(ServiceProvider, value => Visuals.ForEach(x => x.IsVisible = value)); gameSettingsAsset = editor.Session.AllAssets.FirstOrDefault(x => x.AssetType == typeof(GameSettingsAsset)); if (gameSettingsAsset != null) { gameSettingsAsset.PropertyGraph.ItemChanged += GameSettingsPropertyGraphOnItemChanged; gameSettingsAsset.PropertyGraph.Changed += GameSettingsPropertyGraphOnChanged; UpdateNavigationMeshLayers(); } editor.Dispatcher.InvokeTask(async() => { await controller.GameContentLoaded; service = controller.GetService <EditorGameNavigationMeshService>(); UpdateNavigationMeshLayers(); }); }
public MonsterViewModel(Monster monster) { Name = monster.Name; var pathName = monster.Name; if (pathName.Contains("Alatreon") || pathName == "Dire Miralis") { pathName = "Boss"; } ImagePath = string.Format("images\\monsters\\{0}.png", pathName); var array = new [] { monster.FireWeakness, monster.WaterWeakness, monster.ThunderWeakness, monster.IceWeakness, monster.DragonWeakness }; IsValid = array.Any(v => v > 0); Elements = RootViewModel.CreateElements(array); NavigateCommand = new AnonymousCommand(OnNavigate); }
/// <summary> /// Initializes a new instance of the <see cref="TagsViewModel"/> class. /// </summary> /// <param name="assetCollection">The <see cref="AssetCollectionViewModel"/> that will be used to track the list of selected assets.</param> public TagsViewModel(AssetCollectionViewModel assetCollection) : base(assetCollection.SafeArgument(nameof(assetCollection)).ServiceProvider) { this.assetCollection = assetCollection; assetCollection.SelectedAssets.CollectionChanged += SelectedAssetsChanged; AddTagCommand = new AnonymousCommand <string>(ServiceProvider, AddTag); }
public EntityViewModel([NotNull] EntityHierarchyEditorViewModel editor, [NotNull] EntityHierarchyViewModel asset, [NotNull] EntityDesign entityDesign) : base(editor, asset, GetOrCreateChildPartDesigns((EntityHierarchyAssetBase)asset.Asset, entityDesign), entityDesign.Entity) { if (entityDesign.Entity == null) { throw new ArgumentException(@"entity must contain a non-null asset entity.", nameof(entityDesign)); } EntityDesign = entityDesign; var assetNode = Editor.NodeContainer.GetOrCreateNode(entityDesign.Entity); nameNodeBinding = new MemberGraphNodeBinding <string>(assetNode[nameof(Entity.Name)], nameof(Name), OnPropertyChanging, OnPropertyChanged, Editor.UndoRedoService); componentsNodeBinding = new ObjectGraphNodeBinding <EntityComponentCollection>(assetNode[nameof(Entity.Components)].Target, nameof(Components), OnPropertyChanging, OnPropertyChanged, Editor.UndoRedoService, false); modelComponent = new ModelComponentViewModel(ServiceProvider, this); particleComponent = new ParticleSystemComponentViewModel(ServiceProvider, this); cameraComponent = new CameraComponentViewModel(ServiceProvider, this); transformationNode = Editor.NodeContainer.GetNode(AssetSideEntity.Transform)[nameof(TransformComponent.Children)].Target; transformationNode.ItemChanging += TransformChildrenChanging; transformationNode.ItemChanged += TransformChildrenChanged; RenameCommand = new AnonymousCommand(ServiceProvider, () => IsEditing = true); FocusOnEntityCommand = new AnonymousCommand(ServiceProvider, FocusOnEntity); UpdateSourcePrefab(); var basePrefabNode = Editor.NodeContainer.GetNode(EntityDesign)[nameof(EntityDesign.Base)]; basePrefabNode.ValueChanged += BasePrefabChanged; }
public LoadoutSelectorViewModel(bool isManageMode, Action <bool?> endFunc, IEnumerable <AbilityViewModel> abilities) { IsManageMode = isManageMode; this.endFunc = endFunc; this.abilities = abilities; AcceptCommand = new AnonymousCommand(OnAccept); CancelCommand = new AnonymousCommand(OnCancel); Dictionary <string, SkillLoadoutItemConfigurationV3> loadoutConfig = GlobalData.Instance?.Configuration?.SkillLoadouts; if (loadoutConfig == null) { return; } Loadouts = new ObservableCollection <LoadoutViewModel>( loadoutConfig.Select(x => new LoadoutViewModel(isManageMode, x.Key, CreateAbilities(x.Value.Skills), x.Value.WeaponSlots, this)) ); if (Loadouts.Count > 1) { SelectedLoadout = Loadouts[1]; } }
public AssetDependenciesViewModel(AssetViewModel asset, bool forcedRoot) : base(asset.SafeArgument(nameof(asset)).ServiceProvider) { Asset = asset; ToggleIsRootOnSelectedAssetCommand = new AnonymousCommand(ServiceProvider, () => IsRoot = !IsRoot); ForcedRoot = forcedRoot; DirtyDependencies.Add(asset); }
internal VsixVersionViewModel(LauncherViewModel launcher, NugetStore store) : base(launcher, store, null) { ExecuteActionCommand = new AnonymousCommand(ServiceProvider, ExecuteAction) { IsEnabled = false }; }
public SearchResultSortItemViewModel(SearchResultProcessingContainerViewModel parent) { this.parent = parent; MoveSelfUpCommand = new AnonymousCommand(OnMoveSelfUp); MoveSelfDownCommand = new AnonymousCommand(OnMoveSelfDown); RemoveSelfCommand = new AnonymousCommand(OnRemoveSelf); }
public DebugAssetNodeCollectionViewModel(SessionViewModel session) : base(session.SafeArgument(nameof(session)).ServiceProvider) { this.session = session; RefreshQuantumNodesCommand = new AnonymousCommand(ServiceProvider, RefreshQuantumViewModel); //SelectNodeCommand = new AnonymousCommand<Guid>(ServiceProvider, SelectNodeByGuid); }
protected CombinedObservableNode(ObservableViewModel ownerViewModel, string name, IEnumerable <SingleObservableNode> combinedNodes, Index index) : base(ownerViewModel, index) { // ReSharper disable once DoNotCallOverridableMethodsInConstructor DependentProperties.Add(nameof(Value), new[] { nameof(HasMultipleValues), nameof(IsPrimitive), nameof(HasList), nameof(HasDictionary) }); this.combinedNodes = new List <SingleObservableNode>(combinedNodes); Name = name; DisplayName = this.combinedNodes.First().DisplayName; combinedNodeInitialValues = new List <object>(); distinctCombinedNodeInitialValues = new HashSet <object>(); bool isReadOnly = false; bool isVisible = false; bool nullOrder = false; foreach (var node in this.combinedNodes) { if (node.IsDisposed) { throw new InvalidOperationException("One of the combined node is already disposed."); } if (node.IsReadOnly) { isReadOnly = true; } if (node.IsVisible) { isVisible = true; } if (node.Order == null) { nullOrder = true; } if (order == node.Order || (!nullOrder && order == null)) { order = node.Order; } combinedNodeInitialValues.Add(node.Value); distinctCombinedNodeInitialValues.Add(node.Value); } IsReadOnly = isReadOnly; IsVisible = isVisible; ResetInitialValues = new AnonymousCommand(ServiceProvider, () => { using (Owner.BeginCombinedAction(Owner.FormatCombinedUpdateMessage(this, null), Path)) { CombinedNodes.Zip(combinedNodeInitialValues).ForEach(x => x.Item1.Value = x.Item2); Refresh(); } }); }
public ExistingProjectViewModel(IViewModelServiceProvider serviceProvider, UFile path, Action <ExistingProjectViewModel> removeAction) : base(serviceProvider) { Path = path; Id = Guid.NewGuid(); RemoveAction = removeAction ?? throw new ArgumentNullException(nameof(removeAction)); ExploreCommand = new AnonymousCommand(serviceProvider, Explore); RemoveCommand = new AnonymousCommand(serviceProvider, Remove); }
/// <summary> /// Initializes a new instance of the <see cref="LoggerViewModel"/> class. /// </summary> /// <param name="serviceProvider">A service provider that can provide a <see cref="IDispatcherService"/> to use for this view model.</param> public LoggerViewModel(IViewModelServiceProvider serviceProvider) : base(serviceProvider) { AddLoggerCommand = new AnonymousCommand <Logger>(serviceProvider, AddLogger); RemoveLoggerCommand = new AnonymousCommand <Logger>(serviceProvider, RemoveLogger); ClearLoggersCommand = new AnonymousCommand(serviceProvider, ClearLoggers); ClearMessagesCommand = new AsyncCommand(serviceProvider, ClearMessages); messages.CollectionChanged += MessagesCollectionChanged; }
public PreviewViewModel(SessionViewModel session) : base(session.SafeArgument(nameof(session)).ServiceProvider) { this.session = session; session.ActiveAssetView.SelectedAssets.CollectionChanged += SelectedAssetsCollectionChanged; session.ActiveAssetsChanged += ActiveAssetsChanged; RenderPreviewCommand = new AnonymousCommand <bool>(session.ServiceProvider, SetIsVisible); }
// Note: constructor needed by UIElementViewModelFactory public PanelViewModel([NotNull] UIEditorBaseViewModel editor, [NotNull] UIBaseViewModel asset, [NotNull] UIElementDesign elementDesign) : base(editor, asset, elementDesign, GetOrCreateChildPartDesigns((UIAssetBase)asset.Asset, elementDesign)) { childrenNode = editor.NodeContainer.GetOrCreateNode(AssetSidePanel)[nameof(Panel.Children)].Target; childrenNode.ItemChanged += ChildrenContentChanged; ChangeLayoutTypeCommand = new AnonymousCommand <IUIElementFactory>(ServiceProvider, ChangeLayoutType); UngroupCommand = new AnonymousCommand(ServiceProvider, Ungroup); }
public RootViewModel(Func <Task <WeaponUsageSaveSlotInfo> > onBeginMiniMode) { this.onBeginMiniMode = onBeginMiniMode; Accounts = new ReadOnlyObservableCollection <AccountViewModel>(accounts); MiniModeToggleCommand = new AnonymousCommand(OnMiniMode); CloseCommand = new AnonymousCommand(() => App.Current.Shutdown()); }
public GroupedArmorSetHeaderViewModel(SearchResultsViewModel parent, IList <ArmorSetViewModel> items) { this.parent = parent; SelectionCommand = new AnonymousCommand(OnSelection); foreach (EnumFlagViewModel <SearchResultsGrouping> flag in parent.GroupFlags) { if (flag.IsSet == false) { continue; } switch (flag.EnumValue) { case SearchResultsGrouping.RequiredDecorations: HasRequiredDecorations = true; break; case SearchResultsGrouping.Defense: HasDefense = true; break; case SearchResultsGrouping.SpareSlots: HasSpareSlots = true; break; case SearchResultsGrouping.AdditionalSKills: HasAdditionalSkills = true; break; case SearchResultsGrouping.Resistances: HasResistances = true; break; } } ArmorSetViewModel source = items[0]; Jewels = source.Jewels; AdditionalSkills = source.AdditionalSkills; SpareSlots = source.SpareSlots; TotalBaseDefense = source.TotalBaseDefense; TotalMaxDefense = source.TotalMaxDefense; TotalAugmentedDefense = source.TotalAugmentedDefense; TotalFireResistance = source.TotalFireResistance; TotalWaterResistance = source.TotalWaterResistance; TotalThunderResistance = source.TotalThunderResistance; TotalIceResistance = source.TotalIceResistance; TotalDragonResistance = source.TotalDragonResistance; Items = items; }
/// <summary> /// Initializes a new instance of the <see cref="EditorGridViewModel"/> class. /// </summary> /// <param name="serviceProvider">The service provider for this view model.</param> /// <param name="controller">The controller object for the related editor game.</param> public EditorGridViewModel([NotNull] IViewModelServiceProvider serviceProvider, [NotNull] IEditorGameController controller) : base(serviceProvider) { if (controller == null) { throw new ArgumentNullException(nameof(controller)); } this.controller = controller; ToggleCommand = new AnonymousCommand(ServiceProvider, () => IsVisible = !IsVisible); }
/// <summary> /// Initializes a new instance of the <see cref="LoggerViewModel"/> class. /// </summary> /// <param name="serviceProvider">A service provider that can provide a <see cref="Services.IDispatcherService"/> to use for this view model.</param> public LoggerViewModel([NotNull] IViewModelServiceProvider serviceProvider) : base(serviceProvider) { AddLoggerCommand = new AnonymousCommand <Logger>(serviceProvider, AddLogger); RemoveLoggerCommand = new AnonymousCommand <Logger>(serviceProvider, RemoveLogger); ClearLoggersCommand = new AnonymousCommand(serviceProvider, ClearLoggers); ClearMessagesCommand = new AnonymousCommand(serviceProvider, ClearMessages); ClearNewMessageFlagCommand = new AnonymousCommand(serviceProvider, () => HasNewMessages = false); messages.CollectionChanged += MessagesCollectionChanged; }
/// <summary> /// Initializes a new instance of the <see cref="FixReferencesViewModel{T}"/> class. /// </summary> /// <param name="serviceProvider">The service provider for this view model.</param> /// <param name="dialog">The dialog shown to fix references. Can be null for unattended usage.</param> protected FixReferencesViewModel(IViewModelServiceProvider serviceProvider, IFixReferencesDialog dialog) : base(serviceProvider) { this.dialog = dialog; CurrentReplacements = new ObservableList <ReferenceReplacementViewModel <T> >(); PickupSingleReplacementObjectCommand = new AnonymousTaskCommand(serviceProvider, PickupSingleReplacementObject); FixReferencesCommand = new AnonymousCommand(serviceProvider, () => FixReferences()); ClearReferencesCommand = new AnonymousCommand(serviceProvider, () => ClearReferences()); ClearAllReferencesCommand = new AnonymousCommand(serviceProvider, ClearAllReferences); }
public RootViewModel(Window window) { if (window == null) throw new ArgumentNullException("window"); this.window = window; Upload = new UploadViewModel(); ConnectCommand = new AnonymousCommand(OnConnect); CloseCommand = new AnonymousCommand(App.Current.Shutdown); AboutCommand = new AnonymousCommand(OnAbout); }
public UploadFileViewModel(string filename) { Filename = filename; CopyToClipboardCommand = new AnonymousCommand(OnCopyToClipboard); }