public static void RegisterAction(IActionItem action)
{
if (actions.ContainsKey(action.GetItemId()))
throw new Exception(String.Format("Action {0} has a duplicate ItemId {1}.", action.GetType().Name, action.GetItemId()));
actions.Add(action.GetItemId(), action);
}
private void ExecuteAction(IActionItem action)
{
if (action != null)
{
action.Execute();
HideMe();
}
}
public IActionItemManager ShowItem(IActionItem item)
{
//pass the instance on to the parent manager.
parentManager.ShowItem(item);
//also keep a reference for activation
scopeItems.Add(item);
return this;
}
private void OnS2SerialGroupCompleted(IActionItem action)
{
nodeIdToInclude = 0;
if (_inclusionControllerStatusUpdateCallback != null)
{
_inclusionControllerStatusUpdateCallback(null, true);
}
}
public IActionItemManager ShowItem(IActionItem item)
{
//pass the instance on to the parent manager.
parentManager.ShowItem(item);
//also keep a reference for activation
scopeItems.Add(item);
return(this);
}
public static void RegisterAction(IActionItem action)
{
if (actions.ContainsKey(action.GetItemId()))
{
throw new Exception(String.Format("Action {0} has a duplicate ItemId {1}.", action.GetType().Name, action.GetItemId()));
}
actions.Add(action.GetItemId(), action);
}
/// <summary>
/// Initializes a new instance of the <see cref="ActionItemViewModel"/> class.
/// </summary>
/// <param name="serviceProvider">A service provider that can provide a <see cref="IDispatcherService"/> to use for this view model.</param>
/// <param name="actionItem">The action item linked to this view model.</param>
public ActionItemViewModel(IViewModelServiceProvider serviceProvider, IActionItem actionItem)
: base(serviceProvider)
{
if (actionItem == null)
throw new ArgumentNullException(nameof(actionItem));
ActionItem = actionItem;
DisplayName = actionItem.Name;
Refresh();
}
public ActionItemManagerWithParent(IActionItemManager parentManager, ObservableCollection <IActionItem> parentItems, string parentName)
{
this.parentItems = parentItems;
parent = parentItems.FirstOrDefault(item => item.Name == parentName);
if (parent == null)
{
//if there is no parent item create it and add it to the sibling collection
parent = new ActionItem(parentName, null);
parentManager.ShowItem(parent);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ActionItemViewModel"/> class.
/// </summary>
/// <param name="serviceProvider">A service provider that can provide a <see cref="IDispatcherService"/> to use for this view model.</param>
/// <param name="actionItem">The action item linked to this view model.</param>
public ActionItemViewModel(IViewModelServiceProvider serviceProvider, IActionItem actionItem)
: base(serviceProvider)
{
if (actionItem == null)
{
throw new ArgumentNullException(nameof(actionItem));
}
ActionItem = actionItem;
DisplayName = actionItem.Name;
Refresh();
}
private void OnRxTimerActionCompleted(IActionItem action)
{
var actionRxTimerAction = (ActionSerialGroup)action;
if (actionRxTimerAction.Actions[2].Token.State == ActionStates.Expired)
{
lock (_lockObject)
{
RxReset();
}
}
}
private void OnNodeInfoCompleted(IActionItem actionItem)
{
nodeIdToInclude = 0;
if (_updateCallback != null)
{
var action = actionItem as ActionBase;
if (action != null)
{
_updateCallback(action.Result);
}
}
}
/// <inheritdoc/>
public override void Add(IActionItem item)
{
if (!UndoRedoInProgress && TransactionStack.Count > 0)
{
var currentTransaction = TransactionStack.Peek();
currentTransaction.Add(item);
}
else
{
base.Add(item);
}
}
private void FinishActionItem(IActionItem actionItem, NWPlayer user, NWItem item, NWObject target, Location targetLocation, Vector userStartPosition, CustomData customData)
{
user.IsBusy = false;
Vector userPosition = user.Position;
if (userPosition.m_X != userStartPosition.m_X ||
userPosition.m_Y != userStartPosition.m_Y ||
userPosition.m_Z != userStartPosition.m_Z)
{
user.SendMessage("You move and interrupt your action.");
return;
}
if (actionItem.MaxDistance() > 0.0f)
{
if (_.GetDistanceBetween(user.Object, target.Object) > actionItem.MaxDistance() ||
user.Area.Resref != target.Area.Resref)
{
user.SendMessage("Your target is too far away.");
return;
}
}
if (!target.IsValid && !actionItem.AllowLocationTarget())
{
user.SendMessage("Unable to locate target.");
return;
}
string invalidTargetMessage = actionItem.IsValidTarget(user, item, target, targetLocation);
if (!string.IsNullOrWhiteSpace(invalidTargetMessage))
{
user.SendMessage(invalidTargetMessage);
return;
}
actionItem.ApplyEffects(user, item, target, targetLocation, customData);
if (actionItem.ReducesItemCharge(user, item, target, targetLocation, customData))
{
if (item.Charges > 0)
{
item.ReduceCharges();
}
else
{
item.Destroy();
}
}
}
public override Task <IActionItem> Execute(IContent content, object index, object parameter, IEnumerable <IDirtiable> dirtiables)
{
var currentValue = content.Retrieve(index);
var newValue = ChangeValue(currentValue, parameter);
IActionItem actionItem = null;
if (!Equals(newValue, currentValue))
{
content.Update(newValue, index);
actionItem = new ContentValueChangedActionItem("Change property via command '{Name}'", content, index, currentValue, dirtiables);
}
return(Task.FromResult(actionItem));
}
public override ActionResult Execute(IActionItem action)
{
ActionResult ret = base.Execute(action);
if (action is SetLearnModeSlaveOperation)
{
SetLearnModeResult res = (SetLearnModeResult)ret;
if (res)
{
Id = res.NodeId;
}
}
return(ret);
}
public ShortcutActionProperties(IActionItem selectedActionItem)
{
InitializeComponent();
this.MinimumSize = this.Size;
SelectedActionItem = selectedActionItem;
ActionTypesList = Enum.GetValues(typeof(ActionTypes)).Cast<ActionTypes>().ToList();
cbActionType.DataSource = ActionTypesList.Select(at => new { Text = at.DisplayText(), Value = at }).ToList();
cbActionType.ValueMember = "Value";
cbActionType.DisplayMember = "Text";
cbActionType.SelectedIndex = ActionTypesList.FindIndex(a => a == selectedActionItem.ActionType);
}
public ShortcutActionProperties(IActionItem selectedActionItem)
{
InitializeComponent();
this.MinimumSize = this.Size;
SelectedActionItem = selectedActionItem;
ActionTypesList = Enum.GetValues(typeof(ActionTypes)).Cast <ActionTypes>().ToList();
cbActionType.DataSource = ActionTypesList.Select(at => new { Text = at.DisplayText(), Value = at }).ToList();
cbActionType.ValueMember = "Value";
cbActionType.DisplayMember = "Text";
cbActionType.SelectedIndex = ActionTypesList.FindIndex(a => a == selectedActionItem.ActionType);
}
/// <inheritdoc/>
public virtual void Add(IActionItem item)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
var items = new[] { item };
if (UndoRedoInProgress)
{
OnActionItemsDiscarded(new DiscardedActionItemsEventArgs <IActionItem>(ActionItemDiscardType.UndoRedoInProgress, items));
return;
}
InternalAddRange(items);
}
public ArchiSteamFarmPlusPage()
{
ViewModel = IViewModelManager.Instance.GetMainPageViewModel <VM>();
Actions = Interface.InitToolbarItems(this);
ASFService.Current.WhenAnyValue(x => x.IsASFRuning).Subscribe(value =>
{
const VM.ActionItem actionItem = VM.ActionItem.StartOrStop;
if (Actions.ContainsKey(actionItem))
{
var item = Actions[actionItem];
IActionItem <VM.ActionItem> itemHost = ViewModel;
item.Text = itemHost.ToString2(actionItem);
item.IconImageSource = itemHost.GetIcon(actionItem);
}
});
}
public void InsertItems(IActionItem rootItem, HtmlHelper htmlHelper)
{
if (rootItem == null)
{
return;
}
if (rootItem.Uid != ToolbarBuilder.DefaultActionsToolbarUid)
{
return;
}
var group = rootItem.Items.FirstOrDefault(item => item != null && item.Uid == "HomePageToolbarGroup") as ActionToolbarGroup;
if (group != null)
{
GetItems(rootItem, htmlHelper).ForEach(item => group.Items.Add(item));
}
}
private static IEnumerable <DirtiableActionItem> GetDirtiableItems(IActionItem actionItem)
{
var dirtiableActionItem = actionItem as DirtiableActionItem;
if (dirtiableActionItem != null)
{
return new[] { dirtiableActionItem }
}
;
var aggegateActionItem = actionItem as AggregateActionItem;
if (aggegateActionItem != null)
{
return(aggegateActionItem.GetInnerActionItems().OfType <DirtiableActionItem>());
}
return(Enumerable.Empty <DirtiableActionItem>());
}
protected override void CreateInstance()
{
_isAssignCompleteReceived = false;
Mode = Mode == LearnModes.NodeAnyS2 ? LearnModes.LearnModeClassic : Mode;
_setLearnModeStart = new ApiMessage(CommandTypes.CmdZWaveSetLearnMode, new byte[] { (byte)Mode });
_setLearnModeStart.SetSequenceNumber(SequenceNumber);
_setLearnModeStop = new ApiMessage(CommandTypes.CmdZWaveSetLearnMode, new byte[] { (byte)LearnModes.LearnModeDisable });
_setLearnModeStop.SetSequenceNumber(0);
_stopDelay = new TimeInterval(22, 200);
_learnReady = new ApiHandler(FrameTypes.Response, CommandTypes.CmdZWaveSetLearnMode);
_learnReady.AddConditions(new ByteIndex(0x01));
_assignComplete = new ApiHandler(FrameTypes.Request, CommandTypes.CmdZWaveSetLearnMode);
_assignComplete.AddConditions(ByteIndex.AnyValue, new ByteIndex((byte)AssignStatuses.AssignComplete));
_assignNodeIdDone = new ApiHandler(FrameTypes.Request, CommandTypes.CmdZWaveSetLearnMode);
_assignNodeIdDone.AddConditions(ByteIndex.AnyValue, new ByteIndex((byte)AssignStatuses.AssignNodeIdDone));
_assignRangeInfoUpdate = new ApiHandler(FrameTypes.Request, CommandTypes.CmdZWaveSetLearnMode);
_assignRangeInfoUpdate.AddConditions(ByteIndex.AnyValue, new ByteIndex((byte)AssignStatuses.AssignRangeInfoUpdate));
_exploreRequestInclusion = new ApiMessage(CommandTypes.CmdZWaveExploreRequestInclusion);
_exploreRequestInclusion.SetSequenceNumber(SequenceNumber);
_exploreRequestInclusion.IsNoAck = true;
_exploreRequestExclusion = new ApiMessage(CommandTypes.CmdZWaveExploreRequestExclusion);
_exploreRequestExclusion.SetSequenceNumber(SequenceNumber);
_exploreRequestExclusion.IsNoAck = true;
_sendNodeInfo = new ApiMessage(CommandTypes.CmdZWaveSendNodeInformation, 0xFF, (byte)TransmitOptions.TransmitOptionNone);
_sendNodeInfo.SetSequenceNumber(SequenceNumber);
_sendNodeInfoRetFail = new ApiHandler(FrameTypes.Response, CommandTypes.CmdZWaveSendNodeInformation);
_sendNodeInfoRetFail.AddConditions(new ByteIndex(0x00));
_sendNodeInfoCallback = new ApiHandler(FrameTypes.Request, CommandTypes.CmdZWaveSendNodeInformation);
_sendNodeInfoCallback.AddConditions(ByteIndex.AnyValue, ByteIndex.AnyValue);
}
public static string ToString(IActionItem actionItem)
{
var str = "";
if (!string.IsNullOrEmpty(actionItem.Raw))
// always use Raw if possible as it will preserve placement of projects and contexts
{
var reg = new Regex(CompletedPattern, RegexOptions.IgnoreCase);
var rawCompleted = reg.IsMatch(actionItem.Raw);
str = actionItem.Raw;
// we only need to mess with the raw string if its completed status has changed
if (rawCompleted != actionItem.IsComplete)
{
if (actionItem.IsComplete)
{
if (!Settings.PreservePriorityOnComplete)
{
str = Regex.Replace(actionItem.Raw, PriorityPattern, "");
}
str = "x " + ToString(actionItem.CompletionDate) + " " + str;
}
else
{
str = reg.Replace(actionItem.Raw, "").Trim();
}
}
}
else
{
str = string.Format("{0}{1}{2} {3} {4}",
actionItem.IsComplete ? "x " + ToString(actionItem.CompletionDate) + " " : "",
actionItem.Priority == null ? "N/A" : actionItem.Priority + " ",
actionItem.Body,
string.Join(" ", actionItem.Projects),
string.Join(" ", actionItem.Contexts));
}
return(str);
}
/// <summary>
/// Note, this method is iterating all action tbales and actions (for this example to also be able to find built-in actions).
/// Normally, if you only need your own, you can use actionManager.FindTable(context); but when using the
/// CuiActionCommandAdapter, the context is not available, so this method is still the best option.
/// To find only your actions, if you make all your CuiActionCommandAdapter actions use the same category(s),
/// then you can use the table name to find your table (category), then iterate just your the commands.
/// </summary>
static void LookupActions()
{
var actionManager = GlobalInterface.Instance.COREInterface.ActionManager;
//actionManager.FindTable();
for (var actionTableIndex = 0; actionTableIndex < actionManager.NumActionTables; ++actionTableIndex)
{
var actionTable = actionManager.GetTable(actionTableIndex);
//actionTable.
for (var actionIndex = 0; actionIndex < actionTable.Count; ++actionIndex)
{
var action = actionTable[actionIndex];
// finds our known cui action.
if (action != null && action.DescriptionText == MenuItemStrings.actionWindow)
{
m_window = action;
}
}
}
}
private int GetActionOrder(IActionItem action)
{
switch (action.DescriptionText)
{
case ActionStrings.MonitorJobsActionText:
return 1;
case ActionStrings.MonitorPoolsActionText:
return 2;
case ActionStrings.ManageDataActionText:
return 3;
case ActionStrings.SubmitJobActionText:
return 4;
default:
return -1;
}
}
private int GetActionOrder(IActionItem action)
{
switch (action.DescriptionText)
{
case ActionStrings.MonitorJobsActionText:
return(1);
case ActionStrings.MonitorPoolsActionText:
return(2);
case ActionStrings.ManageDataActionText:
return(3);
case ActionStrings.SubmitJobActionText:
return(4);
default:
return(-1);
}
}
/// <summary>
///
/// </summary>
/// <param name="rootItem"></param>
/// <param name="htmlHelper"></param>
/// <returns></returns>
public IEnumerable <IActionItem> GetItems(IActionItem rootItem, HtmlHelper htmlHelper)
{
if (rootItem == null)
{
yield break;
}
if (rootItem.Uid != ToolbarBuilder.DefaultActionsToolbarUid)
{
yield break;
}
if (!rootItem.Items.Any(item => item is ActionToolbarGroup && item.Uid == "HomePageToolbarGroup"))
{
yield break;
}
yield return(new ActionToolbarItem
{
Url = htmlHelper.Url().Action("Index", "Home", new { area = RouteProvider.AreaName }),
Text = SR.T("Перевод")
});
}
private void OnRequestSucNodeInfoGroupCompleted(IActionItem obj)
{
var requestSucNodeInfoGroup = (ActionSerialGroup)obj;
if (requestSucNodeInfoGroup.IsStateCompleted)
{
var result = requestSucNodeInfoGroup.Result.InnerResults.Last() as RequestNodeInfoResult;
if (result != null && result)
{
byte[] supported = result.CommandClasses;
byte[] secureSupported = result.SecureCommandClasses;
if ((supported != null && supported.Contains(COMMAND_CLASS_INCLUSION_CONTROLLER.ID)) ||
(secureSupported != null && secureSupported.Contains(COMMAND_CLASS_INCLUSION_CONTROLLER.ID)))
{
(_addNode as ApiOperation).SubstituteSettings.SetFlag(SubstituteFlags.DenySecurity);
_requestInclusionController.DestNodeId = _getSucNodeId.SpecificResult.SucNodeId;
return;
}
}
}
_requestInclusionController.Token.SetCancelled();
}
public void AddMenuItem(string i_ItemTitle, string i_ParentItem = "", object i_Action = null)
{
if (i_ParentItem == string.Empty) // add to root level
{
if (i_Action == null)
{
m_MenuTree[m_MenuTree.Count] = new MenuItem(i_ItemTitle);
}
else
{
IActionItem action = i_Action as IActionItem;
if (action != null)
{
m_MenuTree[m_MenuTree.Count] = new ActionItem(i_ItemTitle, action);
}
}
}
else
{
Dictionary <int, MenuItem> parentMenu = getParentMenu(i_ParentItem);
MenuItem parentItem = getParentItem(i_ParentItem, parentMenu);
if (parentMenu != null)
{
if (i_Action == null)
{
parentItem.AddChild(new MenuItem(i_ItemTitle, parentMenu));
}
else
{
IActionItem action = i_Action as IActionItem;
if (action != null)
{
parentItem.AddChild(new ActionItem(i_ItemTitle, action, parentMenu));
}
}
}
}
}
private static void DoActionItem(ShortcutItem ActiveShortcutItem, int itemIndex, ExtendedScreenshot ActionItemScreenshot)
{
if (ActiveShortcutItem == null || itemIndex >= ActiveShortcutItem.ActionChain.ActionItems.Count)
{
Trace.WriteLine("No more action items to execute", string.Format("Program.DoActionItem [{0}]", System.Threading.Thread.CurrentThread.Name));
//todo: Why can't the hook be reinstated on the action thread?
Preview.BeginInvoke(new MethodInvoker(() => KeyboardHook.isPaused = false));
IconAnimation.CancelAsync();
return;
}
IActionItem CurrentActionItem = ActiveShortcutItem.ActionChain.ActionItems[itemIndex];
//don't try and invoke the scrolling screenshot actions if they're the first type in the action chain (eg, solo items for their shortcuts) and there's no active scrolling screenshot happening
//at least this solves flashing the icon whenever 'End' key is pressed during normal computer use
if (!Program.isTakingScrollingScreenshot && (CurrentActionItem.ActionType == ActionTypes.ContinueScrollingScreenshot || CurrentActionItem.ActionType == ActionTypes.EndScrollingScreenshot) && itemIndex == 0)
{
return;
}
KeyboardHook.isPaused = true;
Trace.WriteLine(CurrentActionItem.ActionType, string.Format("Program.DoActionItem [{0}]", System.Threading.Thread.CurrentThread.Name));
//todo: figure out a better way to do these exclusions rather than harcoding behavior for scrolling screenshots
if (!IconAnimation.IsBusy)
{
if ((new[] { ActionTypes.ContinueScrollingScreenshot, ActionTypes.EndScrollingScreenshot }.Contains(CurrentActionItem.ActionType) && isTakingScrollingScreenshot) || !new[] { ActionTypes.ContinueScrollingScreenshot, ActionTypes.EndScrollingScreenshot }.Contains(CurrentActionItem.ActionType))
{
IconAnimation.RunWorkerAsync();
}
}
Task.Factory.StartNew <ExtendedScreenshot>(() => CurrentActionItem.Invoke(ActionItemScreenshot))
.ContinueWith(t => DoActionItem(ActiveShortcutItem, itemIndex + 1, t.Result));
}
/// <summary>
/// The get value source.
/// </summary>
/// <param name="field">
/// The field.
/// </param>
/// <param name="list">
/// The list.
/// </param>
/// <returns>
/// The get value source.
/// </returns>
private string GetValueSource(XCrmField field, AdaptedResultList list)
{
switch ((Core.Data.ValueFromType)field.UseValueType)
{
case Core.Data.ValueFromType.FromForm:
AdaptedControlResult formField = list.GetEntryByID(field.FormValueFrom);
if (formField != null)
{
return(formField.FieldName);
}
break;
case Core.Data.ValueFromType.FromCrm:
return("crm");
case Core.Data.ValueFromType.Manual:
return("manual");
case Core.Data.ValueFromType.PreviousAction:
FormItem form = this.CurrentForm;
if (form != null)
{
IActionItem action = DependenciesManager.ActionExecutor.GetAcitonByUniqId(form, field.CrmValue, true);
if (action != null)
{
return("previous action: {0}".FormatWith(action.DisplayName));
}
}
return("previous action: {0}".FormatWith(field.CrmValue));
}
return(string.Empty);
}
private void initMenu(IntPtr objPtr, IntPtr infoPtr)
{
// Set up menu
menuManager = Loader.Core.MenuManager;
string mainMenu = "&SDK Test Menu";
//cleanup menu
MenuBox = menuManager.FindMenu(mainMenu);
if (MenuBox != null)
{
menuManager.UnRegisterMenu(MenuBox);
Loader.Global.ReleaseIMenu(MenuBox);
MenuBox = null;
}
// Main menu
MenuBox = Loader.Global.IMenu;
MenuBox.Title = mainMenu;
menuManager.RegisterMenu(MenuBox, 0);
// sub menu
for (int i = 0; i < actionTable.Count; i++)
{
IActionItem action = actionTable[i];
IIMenuItem mItem = Loader.Global.IMenuItem;
mItem.Title = action.ButtonText;
mItem.ActionItem = action;
MenuBox.AddItem(mItem, -1);
}
//MenuBox -> MenuBoxItem -> MainMenuBar
MenuBoxItem = Loader.Global.IMenuItem;
MenuBoxItem.SubMenu = MenuBox;
menuManager.MainMenuBar.AddItem(MenuBoxItem, -1);
Loader.Global.COREInterface.MenuManager.UpdateMenuBar();
}
public override void Add(IActionItem item)
{
Dispatcher.Invoke(() => base.Add(item));
}
public ActionItemManagerWithParent(IActionItemManager parentManager, ObservableCollection<IActionItem> parentItems, string parentName)
{
this.parentItems = parentItems;
parent = parentItems.FirstOrDefault(item => item.Name == parentName);
if (parent == null)
{
//if there is no parent item create it and add it to the sibling collection
parent = new ActionItem(parentName, null);
parentManager.ShowItem(parent);
}
}
public IActionItemManager ShowItem(IActionItem item)
{
Items.Add(item);
return this;
}
/// <inheritdoc/>
public bool ContainsAction(IActionItem actionItem)
{
return ActionItems.Any(x => x == actionItem || (x is IAggregateActionItem && ((IAggregateActionItem)x).ContainsAction(actionItem)));
}
public ActionItem(IActionItem ai) { this.ai = ai; }
private void btSave_Click(object sender, EventArgs e)
{
ResultActionItem = pgActionProperties.SelectedObject as IActionItem;
}
public override void Add(IActionItem item)
{
Dispatcher.Invoke(() => base.Add(item));
}
private void OnFinishActionItem(OnFinishActionItem data)
{
using (new Profiler(nameof(FinishActionItem)))
{
IActionItem actionItem = ItemService.GetActionItemHandler(data.ClassName);
data.Player.IsBusy = false;
Vector userPosition = data.Player.Position;
if (userPosition.X != data.UserPosition.X ||
userPosition.Y != data.UserPosition.Y ||
userPosition.Z != data.UserPosition.Z)
{
data.Player.SendMessage("You move and interrupt your action.");
return;
}
float maxDistance = actionItem.MaxDistance(data.Player, data.Item, data.Target, data.TargetLocation);
if (maxDistance > 0.0f)
{
NWObject owner = GetItemPossessor(data.Target);
if (data.Target.IsValid && owner.IsValid)
{
// We are okay - we have targeted an item in our inventory (we can't target someone
// else's inventory, so no need to actually check distance).
}
else if (data.Target.Object == _.OBJECT_SELF)
{
// Also okay.
}
else if (data.Target.IsValid &&
(_.GetDistanceBetween(data.Player, data.Target) > maxDistance ||
data.Player.Area.Resref != data.Target.Area.Resref))
{
data.Player.SendMessage("Your target is too far away.");
return;
}
else if (!data.Target.IsValid &&
(_.GetDistanceBetweenLocations(data.Player.Location, data.TargetLocation) > maxDistance ||
data.Player.Area.Resref != ((NWArea)_.GetAreaFromLocation(data.TargetLocation)).Resref))
{
data.Player.SendMessage("That location is too far away.");
return;
}
}
if (!data.Target.IsValid && !actionItem.AllowLocationTarget())
{
data.Player.SendMessage("Unable to locate target.");
return;
}
string invalidTargetMessage = actionItem.IsValidTarget(data.Player, data.Item, data.Target, data.TargetLocation);
if (!string.IsNullOrWhiteSpace(invalidTargetMessage))
{
data.Player.SendMessage(invalidTargetMessage);
return;
}
actionItem.ApplyEffects(data.Player, data.Item, data.Target, data.TargetLocation, data.CustomData);
if (actionItem.ReducesItemCharge(data.Player, data.Item, data.Target, data.TargetLocation, data.CustomData))
{
if (data.Item.Charges > 0)
{
data.Item.ReduceCharges();
}
if (data.Item.Charges <= 0)
{
data.Item.Destroy();
}
}
}
}
private static IEnumerable<DirtiableActionItem> GetDirtiableItems(IActionItem actionItem)
{
var dirtiableActionItem = actionItem as DirtiableActionItem;
if (dirtiableActionItem != null)
return new[] { dirtiableActionItem };
var aggegateActionItem = actionItem as AggregateActionItem;
if (aggegateActionItem != null)
return aggegateActionItem.GetInnerActionItems().OfType<DirtiableActionItem>();
return Enumerable.Empty<DirtiableActionItem>();
}
/// <inheritdoc/>
public void Add(IActionItem item)
{
}
/// <inheritdoc/>
public override void Add(IActionItem item)
{
if (!UndoRedoInProgress && TransactionStack.Count > 0)
{
var currentTransaction = TransactionStack.Peek();
currentTransaction.Add(item);
}
else
{
base.Add(item);
}
}
/// <inheritdoc/>
public virtual void Add(IActionItem item)
{
if (item == null)
throw new ArgumentNullException("item");
var items = new[] { item };
if (UndoRedoInProgress)
{
OnActionItemsDiscarded(new DiscardedActionItemsEventArgs<IActionItem>(ActionItemDiscardType.UndoRedoInProgress, items));
return;
}
InternalAddRange(items);
}
private void InternalAddRange(IActionItem[] items)
{
lock (lockObject)
{
// stack pre-cleanup
UnsafeDisbranchedCleanup();
// add items
foreach (var item in items)
actionItems.Add(item);
// post-cleanup
IActionItem[] discarded = null;
if (capacity >= 0 && actionItems.Count > capacity)
{
// stack is overloaded
discarded = actionItems
.Take(actionItems.Count - capacity)
.ToArray();
int itemsToRemove = actionItems.Count - capacity;
for (int i = 0; i < itemsToRemove; ++i)
{
actionItems[0].Freeze();
actionItems.RemoveAt(0);
}
}
ResetIndexOnTop();
// raise event to notify of cleaned up items
if (discarded != null)
{
OnActionItemsDiscarded(new DiscardedActionItemsEventArgs<IActionItem>(
ActionItemDiscardType.Swallowed,
discarded));
}
// raise event to notify of added items
var added = items;
if (capacity >= 0 && items.Length > capacity)
added = items.Skip(items.Length - capacity).ToArray();
OnActionItemsAdded(new ActionItemsEventArgs<IActionItem>(added));
}
}
