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);
}
