protected virtual void StatefulPerform(CommandKey key, object param)
{
CommandHandler handler;
if (!_handlers.TryGetValue(key, out handler))
{
return;
}
StatefulCommandHandler stateHandler = handler as StatefulCommandHandler;
if (stateHandler == null)
{
return;
}
stateHandler.Selected = !stateHandler.Selected;
if (stateHandler.Perform != null)
{
stateHandler.Perform(param);
}
Invalidate(key);
}
public virtual bool IsSelected(CommandKey key)
{
CommandHandler handler;
if (!_handlers.TryGetValue(key, out handler))
{
return(false);
}
StatefulCommandHandler stateHandler = handler as StatefulCommandHandler;
if (stateHandler != null)
{
return(stateHandler.Selected);
}
CommandGroup group;
if (!_toggleGroups.TryGetValue(handler.Group, out group))
{
return(false);
}
return(group.Selected == key);
}
protected virtual void GroupPerform(CommandKey key, object param)
{
CommandHandler handler;
if (!_handlers.TryGetValue(key, out handler))
{
return;
}
CommandGroup group;
if (!_toggleGroups.TryGetValue(handler.Group, out group))
{
return;
}
if (group.Selected == key)
{
return;
}
group.Selected = key;
if (group.Handler.Perform != null)
{
group.Handler.Perform(param);
}
if (handler.Perform != null)
{
handler.Perform(param);
}
InvalidateGroup(handler.Group);
}
public override void Perform(CommandKey key, object param)
{
if (base.CanHandle(key))
{
base.Perform(key, param);
return;
}
foreach (ICommandSubscriber subscriber in _forwardManagers)
{
if (subscriber == null || subscriber.CommandManager == null)
{
continue;
}
if (!subscriber.CommandManager.CanPerform(key, param))
{
continue;
}
subscriber.CommandManager.Perform(key, param);
if (!IsMulticast)
{
break;
}
}
}
public void RegisterToggle(CommandKey key, Func <object, bool> performCheck, Action <object> perform)
{
_handlers[key] = new StatefulCommandHandler()
{
CanPerform = performCheck ?? DefaultStatefulCheck,
Perform = perform,
};
}
public void Register(CommandKey key, Func <object, bool> performCheck, Action <object> perform)
{
_handlers[key] = new CommandHandler()
{
CanPerform = performCheck,
Perform = perform,
};
}
protected bool CanHandleGroup(CommandKey key)
{
if (!CanHandle(key))
{
return(false);
}
return(CanHandleGroup(_handlers[key].Group));
}
public void RegisterToggle(CommandToggleGroup group, CommandKey key, Func <object, bool> performCheck, Action <object> perform)
{
if (!_toggleGroups[group].Members.Contains(key))
{
_toggleGroups[group].Members.Add(key);
}
Register(key, performCheck, perform);
_handlers[key].Group = group;
}
public virtual void Perform(CommandKey key, object param)
{
if (CanHandleGroup(key))
{
GroupPerform(key, param);
}
else if (CanHandle(key))
{
if (_handlers[key] is StatefulCommandHandler)
{
StatefulPerform(key, param);
}
else if (_handlers[key].Perform != null)
{
_handlers[key].Perform(param);
}
}
}
public virtual bool CanPerform(CommandKey key, object param)
{
if (!CanHandle(key))
{
return(false);
}
if (GroupCanPerform(key, param))
{
return(true);
}
if (_handlers[key].CanPerform != null && _handlers[key].CanPerform(param))
{
return(true);
}
return(false);
}
public override bool CanPerform(CommandKey key, object param)
{
if (base.CanHandle(key))
{
return(base.CanPerform(key, param));
}
foreach (ICommandSubscriber subscriber in _forwardManagers)
{
if (subscriber == null || subscriber.CommandManager == null)
{
continue;
}
if (subscriber.CommandManager.CanPerform(key, param))
{
return(true);
}
}
return(false);
}
public override bool IsSelected(CommandKey key)
{
if (base.CanHandle(key))
{
return(base.IsSelected(key));
}
foreach (ICommandSubscriber subscriber in _forwardManagers)
{
if (subscriber == null || subscriber.CommandManager == null)
{
continue;
}
if (subscriber.CommandManager.IsSelected(key))
{
return(true);
}
}
return(false);
}
public override CommandKey SelectedCommand(CommandToggleGroup group)
{
if (base.CanHandleGroup(group))
{
return(base.SelectedCommand(group));
}
foreach (ICommandSubscriber subscriber in _forwardManagers)
{
if (subscriber == null || subscriber.CommandManager == null)
{
continue;
}
CommandKey selected = subscriber.CommandManager.SelectedCommand(group);
if (selected != CommandKey.Unknown)
{
return(selected);
}
}
return(CommandKey.Unknown);
}
protected virtual bool GroupCanPerform(CommandKey key, object param)
{
CommandHandler handler;
if (!_handlers.TryGetValue(key, out handler))
{
return(false);
}
CommandGroup group;
if (!_toggleGroups.TryGetValue(handler.Group, out group))
{
return(false);
}
if (group.Handler.CanPerform == null)
{
return(false);
}
return(group.Handler.CanPerform(param));
}
public CommandMenuTag(CommandKey key, object param)
{
_key = key;
_param = param;
}
public void Perform(CommandKey key)
{
Perform(key, null);
}
private void Invalidate(CommandKey key)
{
if (_buttonMap.ContainsKey(key)) {
ToolStripButton item = _buttonMap[key];
item.Enabled = CanPerformCommand(key, TagValueFromItem(item));
item.Checked = IsCommandSelected(key);
}
if (_menuMap.ContainsKey(key)) {
ToolStripMenuItem item = _menuMap[key];
item.Enabled = CanPerformCommand(key, TagValueFromItem(item));
item.Checked = IsCommandSelected(key);
}
}
private void PerformCommand(CommandKey key)
{
if (_commandManager.CanPerform(key))
_commandManager.Perform(key);
}
private bool CanPerformCommand(CommandKey key)
{
return _commandManager != null && _commandManager.CanPerform(key);
}
private bool CanPerformCommand(CommandKey key)
{
if (_editor.CurrentLevel == null || _editor.CurrentLevel.CommandManager == null)
return false;
return _editor.CurrentLevel.CommandManager.CanPerform(key);
}
public CommandMenuEntry(CommandKey key)
{
Key = key;
}
private void MapMenuItem(CommandKey key, ToolStripMenuItem item)
{
if (key != CommandKey.Unknown && item != null) {
_menuMap.Add(key, item);
item.Click += BoundMenuClickHandler;
Invalidate(key);
}
}
public void RegisterToggle(CommandToggleGroup group, CommandKey key, Func <bool> performCheck, Action perform)
{
RegisterToggle(group, key, (obj) => { return(performCheck()); }, (obj) => { perform(); });
}
public void Unregister(CommandKey key)
{
_handlers.Remove(key);
}
public void Invalidate(CommandKey key)
{
OnCommandInvalidated(new CommandSubscriberEventArgs(key));
}
public virtual bool CanHandle(CommandKey key)
{
return(_handlers.ContainsKey(key));
}
public bool CanPerform(CommandKey key)
{
return(CanPerform(key, null));
}
public CommandRecord Lookup(CommandKey key)
{
CommandRecord inst;
if (_registry.TryGetValue(key, out inst))
return inst;
else
return null;
}
private static void Register(CommandKey key, string displayName, Image resource = null, Keys shortcut = Keys.None, string description = null, string shortcutDisplay = null)
{
CommandRecord record = new CommandRecord(key) {
DisplayName = displayName,
Description = description,
Shortcut = shortcut,
ShortcutDisplay = shortcutDisplay,
};
if (resource != null)
record.Image = resource;
_default.Register(record);
}
public void Register(CommandKey key, Func <bool> performCheck, Action perform)
{
Register(key, (obj) => { return(performCheck()); }, (obj) => { perform(); });
}
public CommandMenuEntry(CommandKey key, object param)
: this(key)
{
Param = param;
}
public void RegisterToggle(CommandToggleGroup group, CommandKey key)
{
RegisterToggle(group, key, null as Func <object, bool>, null as Action <object>);
}
private void PerformCommand(CommandKey key)
{
if (_editor.CurrentLevel == null || _editor.CurrentLevel.CommandManager == null)
return;
_editor.CurrentLevel.CommandManager.Perform(key);
}
private static void Register(CommandKey key, string displayName, string resource = null, Keys shortcut = Keys.None, string description = null, string shortcutDisplay = null)
{
CommandRecord record = new CommandRecord(key) {
DisplayName = displayName,
Description = description,
Shortcut = shortcut,
ShortcutDisplay = shortcutDisplay,
};
if (resource != null)
record.Image = Image.FromStream(_assembly.GetManifestResourceStream(resource));
_default.Register(record);
}
private void Invalidate(CommandKey key)
{
if (_commandMap.ContainsKey(key)) {
ToolStripButton item = _commandMap[key];
item.Enabled = CanPerformCommand(key);
item.Checked = IsCommandSelected(key);
}
}
private void Invalidate(CommandKey key)
{
ToolStripButton button;
if (_commandButtonMap.TryGetValue(key, out button)) {
button.Enabled = CanPerformCommand(key);
button.Checked = IsCommandSelected(key);
}
}
private bool CanPerformCommand(CommandKey key, object param)
{
return _commandManager != null && _commandManager.CanPerform(key, param);
}
public CommandRecord(CommandKey key)
{
Key = key;
}
private bool IsCommandSelected(CommandKey key)
{
return _commandManager != null && _commandManager.IsSelected(key);
}
public CommandMenuTag(CommandKey key)
: this(key, null)
{
}
private void PerformCommand(CommandKey key, object param)
{
if (CanPerformCommand(key, param))
_commandManager.Perform(key, param);
}
public CommandSubscriberEventArgs(CommandKey key)
{
CommandKey = key;
}
