public DataFolderViewModel(AppFoldersViewModel appFolders) { _appFolders = appFolders; MoveUpCommand = new ScriptingCommand(() => appFolders.MoveUp(this)); MoveDownCommand = new ScriptingCommand(() => appFolders.MoveDown(this)); DeleteCommand = new ScriptingCommand(() => appFolders.Delete(this)); }
public SamplerCubeViewModel(ScriptViewModel script, ScriptNode node, UrhoContext context) : base(script, node) { _context = context; PickTextureCommand = new ScriptingCommand(PickTexture); ResetTextureCommand = new ScriptingCommand(ResetTexture); UpdateImageSource(); }
public ScriptViewModel(INodeRegistry registry = null, INodeViewModelFactory viewModelFactory = null, Script script = null) { _registry = registry ?? EmptyNodeRegistry.Instance; _viewModelFactory = viewModelFactory ?? new NodeViewModelFactory(_registry); GroupSelectedCommand = new ScriptingCommand(() => GroupSelected()) { CanExecute = false }; UngroupSelectedCommand = new ScriptingCommand(UngroupSelected) { CanExecute = false }; CopySelectedCommand = new ScriptingCommand(CopySelected) { CanExecute = false }; CutSelectedCommand = new ScriptingCommand(CutSelected) { CanExecute = false }; DuplicateSelectedCommand = new ScriptingCommand(DuplicateSelected) { CanExecute = false }; PasteCommand = new ScriptingCommand(() => Paste()) { CanExecute = true }; UndoCommand = new ScriptingCommand(Undo) { CanExecute = false }; RedoCommand = new ScriptingCommand(Redo) { CanExecute = false }; //BindingOperations.SetBinding(UndoCommand, ScriptingCommand.CanExecuteProperty, new Binding //{ // Path = new PropertyPath(nameof(UndoStackViewModel.CanUndo)), // Source = UndoStack //}); //BindingOperations.SetBinding(RedoCommand, ScriptingCommand.CanExecuteProperty, new Binding //{ // Path = new PropertyPath(nameof(UndoStackViewModel.CanRedo)), // Source = UndoStack //}); SelectAllCommand = new ScriptingCommand(SelectAll); DeleteSelectedCommand = new ScriptingCommand(DeleteSelected); ResetZoomCommand = new ScriptingCommand(ResetZoom); if (script != null) { SetScript(script); } }
public void LoadSetting(XElement settingRoot) { commands.Clear(); foreach (XElement element in settingRoot.Elements("ScriptingCommand")) { IObjectEditorType type = provider.Types.Where(t => t.GetType().AssemblyQualifiedName == element.Attribute("Class").Value).FirstOrDefault(); if (type != null) { ScriptingCommand command = (ScriptingCommand)type.CreateObject(); command.LoadSetting(element); commands.Add(command); } } }
public GroupViewModel(ScriptViewModel script, NodeGroup nodeGroup) { Script = script; NodeGroup = nodeGroup; CollapseOrExpandCommand = new ScriptingCommand(CollapseOrExpand); if (nodeGroup.IsCollapsed) { Collapse(); } else { Expand(); } }
public Worker(ScriptingCommand c, ExecutedEventArgs e) { // Keep this worker alive after leaving local scope using a strong reference. Workers.Register(this); CancellationTokenSource = new CancellationTokenSource(); // Store the current context; EntryContext = ScriptingContext.Current; // Keep strong references to the passed arguments. Callback = e.Arguments.ElementAt(0).ToFunction(); Value = e.Arguments.ElementAt(1).ToInteger(); // Keep a references to the command, so we'll be able to detach the event handler later. Command = c; Command.ScriptingContextReleased += OnScriptingContextReleased; }
public MainViewModel(ScriptViewModel scriptViewModel, ShaderGenerator generator, UrhoContext context, GraphValidator validator, ConfigurationRepository <AppConfiguration> config) { _backgroundScheduler = new EventLoopScheduler(); _disposables.Add(_backgroundScheduler); _generator = generator; _context = context; _validator = validator; _config = config; NewCommand = new ScriptingCommand(New); NewEmptyCommand = new ScriptingCommand(NewEmpty); OpenCommand = new ScriptingCommand(Open); MergeCommand = new ScriptingCommand(Merge); SaveCommand = new ScriptingCommand(Save); SaveAsCommand = new ScriptingCommand(SaveAs); ExportCommand = new ScriptingCommand(Export); OpenSceneCommand = new ScriptingCommand <string>(OpenScene); OpenMDLCommand = new ScriptingCommand <string>(OpenMDL); OpenAnimatedMDLCommand = new ScriptingCommand <string>(OpenAnimatedMDL); SetResourcePathCommand = new ScriptingCommand(SetResourcePath); ExitCommand = new ScriptingCommand(Exit); SetRenderPathCommand = new ScriptingCommand <string>(SetRenderPath); SetShadowQualityCommand = new ScriptingCommand <string>(SetShadowQuality); _rearrangeCommand = new ScriptingCommand(() => ScriptViewModel.Rearrange()); _centerGraphCommand = new ScriptingCommand(() => ToCenter()); SaveSelectedAsCommand = new ScriptingCommand(SaveSelectedAs); RunScriptAnalizerCommand = new ScriptingCommand(RunScriptAnalizer); TestAllNodeTypesCommand = new ScriptingCommand(TestAllNodeTypes); TestNodesCommand = new ScriptingCommand(TestNodes); TestPerformanceCommand = new ScriptingCommand(TestPerformance); ScriptViewModel = scriptViewModel; _errors = new Subject <MaterialCompilationException>(); _disposables.Add(_errors.ObserveOnDispatcher().Subscribe(HandleError)); _preview = new Subject <PreviewData>(); _disposables.Add(_preview.Throttle(TimeSpan.FromSeconds(0.1f)).ObserveOn(_backgroundScheduler) .Subscribe(new Generator(this))); ScriptViewModel.ScriptChanged += OnScriptViewModelOnScriptChanged; ScriptViewModel.SelectionChanged += OnScriptViewModelOnSelectionChanged; New(); }
/// <summary>Creates a scripting command from action input.</summary> /// <param name="actionInput">The action input to transform into a ScriptingCommand instance.</param> /// <returns>A new ScriptingCommand instance for the specified input, if found, else null.</returns> public ScriptingCommand Create(ActionInput actionInput) { // TODO: Build targeting into command selection when there are multiple valid targets; IE if multiple // openable things registered an "open" context command, then if the user said "open door" then we // want to select the context command attached to the closest match for "door" as our command; if // there are still multiple targets, we can start a conflict resolution prompt, etc. Individual non- // context commands may also wish to use such targeting code, so it should be built to be reusable. ScriptingCommand command = this.TryCreateMasterCommand(actionInput, 0) ?? this.TryCreateMasterCommand(actionInput, 1) ?? this.TryCreateContextCommand(actionInput, 0) ?? this.TryCreateContextCommand(actionInput, 1); if (command == null) { actionInput.Controller.Write(unknownCommandResponse); } return(command); }
public bool HandleCommand(string command, ref Exception error) { if (command == "edit command") { provider.Load(commands); using (ObjectEditorForm form = new ObjectEditorForm(provider, callback)) { if (form.ShowDialog() == DialogResult.OK) { provider.Save(commands); callback.SaveSettings(); InvokeSuggestedCommandChanged(); } } return(true); } else { ScriptingCommand scriptingCommand = commands.Where(c => c.Name == command).FirstOrDefault(); if (scriptingCommand != null) { try { scriptingCommand.ExecuteCommand(callback); } catch (Exception ex) { error = ex; } return(true); } else { return(false); } } }
/// <summary>Verifies that the proposed command can be performed by the acting entity.</summary> /// <param name="command">The issued command to be carried out.</param> /// <returns>A string defining why the permission was not given, else null if permission is given.</returns> public static string VerifyCommandPermission(ScriptingCommand command) { if (command.SecurityRole == SecurityRole.none) { // If you are debugging here after trying to set up your own action, // you probably forgot to assign an appropriate [ActionSecurity(...)] // attribute for your new GameAction class. return(string.Format("Nobody can use '{0}' right now!", command.Name)); } Thing entity = command.ActionInput.Controller.Thing; if (entity == null) { return("You must exist before issuing commands!"); } PlayerBehavior player = entity.Behaviors.FindFirst <PlayerBehavior>(); if (player != null) { // @@@ TODO: Ascertain the ACTUAL player's specific permissions, so we can // check for fullAdmin, fullBuilder, etc, instead of assuming just // 'SecurityRole.player' SecurityRole playerRoles = SecurityRole.player | SecurityRole.minorBuilder | SecurityRole.fullBuilder | SecurityRole.minorAdmin | SecurityRole.fullAdmin; // If any of the command's security roles and the player's security roles // overlap (such as the command is marked with 'minorBuilder' and the // player has the 'minorBuilder' flag) then we permit the command. if ((command.SecurityRole & playerRoles) != SecurityRole.none) { return(null); } // Otherwise, this player does not have permission; we do not want to // check the mobile/item/room security role on players, so we're done. return(string.Format("You do not have permission to use '{0}' right now.", command.Name)); } MobileBehavior mobile = entity.Behaviors.FindFirst <MobileBehavior>(); if (mobile != null) { if ((command.SecurityRole & SecurityRole.mobile) != SecurityRole.none) { return(null); } return(string.Format("A mobile can not use '{0}' right now!", command.Name)); } RoomBehavior room = entity.Behaviors.FindFirst <RoomBehavior>(); if (room != null) { if ((command.SecurityRole & SecurityRole.room) == SecurityRole.none) { return(null); } return(string.Format("A room can not use '{0}' right now!", command.Name)); } // @@@ For now, everything else which doesn't meet any above category will need the 'item' security // role. (Do we need an ItemBehavior or is there something else relevant... CanPickupBehavior etc?) if ((command.SecurityRole & SecurityRole.item) != SecurityRole.none) { return(null); } return(string.Format("An item (or unrecognized entity) can not use '{0}' right now!", command.Name)); }
public MainViewModel(ScriptViewModel scriptViewModel) { ScriptViewModel = scriptViewModel; OpenCommand = new ScriptingCommand(Open); }
public AppFoldersViewModel(ConfigurationRepository <AppConfiguration> configRepository) { _configRepository = configRepository; Reset(); AddCommand = new ScriptingCommand(AddFolder); }
public FactoryViewModel(ScriptViewModel script, INodeFactory factory) { _script = script; _factory = factory; CreateCommand = new ScriptingCommand(() => Create(script.CreateLocation)); }
/// <summary>Verifies that the proposed command can be performed by the acting entity.</summary> /// <param name="command">The issued command to be carried out.</param> /// <returns>A string defining why the permission was not given, else null if permission is given.</returns> public static string VerifyCommandPermission(ScriptingCommand command) { if (command.SecurityRole == SecurityRole.none) { // If you are debugging here after trying to set up your own action, // you probably forgot to assign an appropriate [ActionSecurity(...)] // attribute for your new GameAction class. return(string.Format("Nobody can use '{0}' right now!", command.Name)); } Thing entity = command.ActionInput.Actor; if (entity == null) { return("You must exist before issuing commands!"); } var user = entity.FindBehavior <UserControlledBehavior>(); if (user != null) { // If any of the command security roles and the user security roles overlap (such as the command is // marked with 'minorBuilder' and the user has the 'minorBuilder' flag) then we permit the command. if ((command.SecurityRole & user.SecurityRoles) != SecurityRole.none) { return(null); } // Otherwise, this player does not have permission; we do not want to // check the mobile/item/room security role on players, so we're done. return(string.Format("You do not have permission to use '{0}' right now.", command.Name)); } MobileBehavior mobile = entity.FindBehavior <MobileBehavior>(); if (mobile != null) { if ((command.SecurityRole & SecurityRole.mobile) != SecurityRole.none) { return(null); } return(string.Format("A mobile can not use '{0}' right now!", command.Name)); } RoomBehavior room = entity.FindBehavior <RoomBehavior>(); if (room != null) { if ((command.SecurityRole & SecurityRole.room) == SecurityRole.none) { return(null); } return(string.Format("A room can not use '{0}' right now!", command.Name)); } // TODO: For now, everything else which doesn't meet any above category will need the 'item' security // role. (Do we need an ItemBehavior or is there something else relevant... CanPickupBehavior etc?) if ((command.SecurityRole & SecurityRole.item) != SecurityRole.none) { return(null); } return(string.Format("An item (or unrecognized entity) can not use '{0}' right now!", command.Name)); }