642 lines
26 KiB
C#
642 lines
26 KiB
C#
#region Using Directives
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Windows.Forms;
|
|
|
|
#endregion Using Directives
|
|
|
|
|
|
namespace ScintillaNET
|
|
{
|
|
/// <summary>
|
|
/// Manages commands, which are actions in ScintillaNET that can be bound to key combinations.
|
|
/// </summary>
|
|
[TypeConverterAttribute(typeof(System.ComponentModel.ExpandableObjectConverter))]
|
|
public class Commands : TopLevelHelper
|
|
{
|
|
#region Fields
|
|
|
|
private Dictionary<KeyBinding, List<BindableCommand>> _boundCommands = new Dictionary<KeyBinding, List<BindableCommand>>();
|
|
private CommandComparer _commandComparer = new CommandComparer();
|
|
|
|
// Hmmm.. This is getting more and more hackyish
|
|
internal bool StopProcessingCommands = false;
|
|
|
|
private bool _allowDuplicateBindings = true;
|
|
|
|
#endregion Fields
|
|
|
|
|
|
#region Methods
|
|
|
|
/// <summary>
|
|
/// Adds a key combination to a Command
|
|
/// </summary>
|
|
/// <param name="shortcut">Character corresponding to a (keyboard) key to trigger command</param>
|
|
/// <param name="command">Command to execute</param>
|
|
public void AddBinding(char shortcut, BindableCommand command)
|
|
{
|
|
AddBinding(Utilities.GetKeys(shortcut), Keys.None, command);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Adds a key combination to a Command
|
|
/// </summary>
|
|
/// <param name="shortcut">Character corresponding to a (keyboard) key to trigger command</param>
|
|
/// <param name="modifiers">Shift, alt, ctrl</param>
|
|
/// <param name="command">Command to execute</param>
|
|
public void AddBinding(char shortcut, Keys modifiers, BindableCommand command)
|
|
{
|
|
AddBinding(Utilities.GetKeys(shortcut), modifiers, command);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Adds a key combination to a Command
|
|
/// </summary>
|
|
/// <param name="shortcut">Key to trigger command</param>
|
|
/// <param name="command">Command to execute</param>
|
|
public void AddBinding(Keys shortcut, BindableCommand command)
|
|
{
|
|
AddBinding(shortcut, Keys.None, command);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Adds a key combination to a Command
|
|
/// </summary>
|
|
/// <param name="shortcut">Key to trigger command</param>
|
|
/// <param name="modifiers">Shift, alt, ctrl</param>
|
|
/// <param name="command">Command to execute</param>
|
|
public void AddBinding(Keys shortcut, Keys modifiers, BindableCommand command)
|
|
{
|
|
KeyBinding kb = new KeyBinding(shortcut, modifiers);
|
|
if (!_boundCommands.ContainsKey(kb))
|
|
_boundCommands.Add(kb, new List<BindableCommand>());
|
|
|
|
List<BindableCommand> l = _boundCommands[kb];
|
|
if (_allowDuplicateBindings || !l.Contains(command))
|
|
l.Add(command);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Executes a Command
|
|
/// </summary>
|
|
/// <param name="command">Any <see cref="BindableCommand"/></param>
|
|
/// <returns>Value to indicate whether other bound commands should continue to execute</returns>
|
|
public bool Execute(BindableCommand command)
|
|
{
|
|
if ((int)command < 10000)
|
|
{
|
|
NativeScintilla.SendMessageDirect((uint)command, IntPtr.Zero, IntPtr.Zero);
|
|
return true;
|
|
}
|
|
|
|
switch (command)
|
|
{
|
|
case BindableCommand.AutoCShow:
|
|
Scintilla.AutoComplete.Show();
|
|
return true;
|
|
|
|
case BindableCommand.AcceptActiveSnippets:
|
|
return Scintilla.Snippets.AcceptActiveSnippets();
|
|
|
|
case BindableCommand.CancelActiveSnippets:
|
|
return Scintilla.Snippets.CancelActiveSnippets();
|
|
|
|
case BindableCommand.DoSnippetCheck:
|
|
return Scintilla.Snippets.DoSnippetCheck();
|
|
|
|
case BindableCommand.NextSnippetRange:
|
|
return Scintilla.Snippets.NextSnippetRange();
|
|
|
|
case BindableCommand.PreviousSnippetRange:
|
|
return Scintilla.Snippets.PreviousSnippetRange();
|
|
|
|
case BindableCommand.DropMarkerCollect:
|
|
Scintilla.DropMarkers.Collect();
|
|
return false;
|
|
|
|
case BindableCommand.DropMarkerDrop:
|
|
Scintilla.DropMarkers.Drop();
|
|
return true;
|
|
|
|
case BindableCommand.Print:
|
|
Scintilla.Printing.Print();
|
|
return true;
|
|
|
|
case BindableCommand.PrintPreview:
|
|
Scintilla.Printing.PrintPreview();
|
|
return true;
|
|
|
|
case BindableCommand.ShowFind:
|
|
Scintilla.FindReplace.ShowFind();
|
|
return true;
|
|
|
|
case BindableCommand.ShowReplace:
|
|
Scintilla.FindReplace.ShowReplace();
|
|
return true;
|
|
|
|
case BindableCommand.FindNext:
|
|
Scintilla.FindReplace.Window.FindNext();
|
|
return true;
|
|
|
|
case BindableCommand.FindPrevious:
|
|
Scintilla.FindReplace.Window.FindPrevious();
|
|
return true;
|
|
|
|
case BindableCommand.IncrementalSearch:
|
|
Scintilla.FindReplace.IncrementalSearch();
|
|
return true;
|
|
|
|
case BindableCommand.LineComment:
|
|
Scintilla.Lexing.LineComment();
|
|
return true;
|
|
|
|
case BindableCommand.LineUncomment:
|
|
Scintilla.Lexing.LineUncomment();
|
|
return true;
|
|
|
|
case BindableCommand.DocumentNavigateForward:
|
|
Scintilla.DocumentNavigation.NavigateForward();
|
|
return true;
|
|
|
|
case BindableCommand.DocumentNavigateBackward:
|
|
Scintilla.DocumentNavigation.NavigateBackward();
|
|
return true;
|
|
|
|
case BindableCommand.ToggleLineComment:
|
|
Scintilla.Lexing.ToggleLineComment();
|
|
return true;
|
|
|
|
case BindableCommand.StreamComment:
|
|
Scintilla.Lexing.StreamComment();
|
|
return true;
|
|
|
|
case BindableCommand.ShowSnippetList:
|
|
Scintilla.Snippets.ShowSnippetList();
|
|
return true;
|
|
|
|
case BindableCommand.ShowSurroundWithList:
|
|
Scintilla.Snippets.ShowSurroundWithList();
|
|
return true;
|
|
|
|
case BindableCommand.ShowGoTo:
|
|
Scintilla.GoTo.ShowGoToDialog();
|
|
break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Returns a list of Commands bound to a keyboard shortcut
|
|
/// </summary>
|
|
/// <param name="shortcut">Character corresponding to a (keyboard) key to trigger command</param>
|
|
/// <returns>List of Commands bound to a keyboard shortcut</returns>
|
|
private List<BindableCommand> GetCommands(char shortcut)
|
|
{
|
|
return GetCommands(Utilities.GetKeys(shortcut), Keys.None);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Returns a list of Commands bound to a keyboard shortcut
|
|
/// </summary>
|
|
/// <param name="shortcut">Character corresponding to a (keyboard) key to trigger command</param>
|
|
/// <param name="modifiers">Shift, alt, ctrl</param>
|
|
/// <returns>List of Commands bound to a keyboard shortcut</returns>
|
|
private List<BindableCommand> GetCommands(char shortcut, Keys modifiers)
|
|
{
|
|
return GetCommands(Utilities.GetKeys(shortcut), modifiers);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Returns a list of Commands bound to a keyboard shortcut
|
|
/// </summary>
|
|
/// <param name="shortcut">Key to trigger command</param>
|
|
/// <returns>List of Commands bound to a keyboard shortcut</returns>
|
|
private List<BindableCommand> GetCommands(Keys shortcut)
|
|
{
|
|
return GetCommands(shortcut, Keys.None);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Returns a list of Commands bound to a keyboard shortcut
|
|
/// </summary>
|
|
/// <param name="shortcut">Key to trigger command</param>
|
|
/// <param name="modifiers">Shift, alt, ctrl</param>
|
|
/// <returns>List of Commands bound to a keyboard shortcut</returns>
|
|
private List<BindableCommand> GetCommands(Keys shortcut, Keys modifiers)
|
|
{
|
|
KeyBinding kb = new KeyBinding(shortcut, modifiers);
|
|
if (!_boundCommands.ContainsKey(kb))
|
|
return new List<BindableCommand>();
|
|
|
|
return _boundCommands[kb];
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Returns a list of KeyBindings bound to a given command
|
|
/// </summary>
|
|
/// <param name="command">Command to execute</param>
|
|
/// <returns>List of KeyBindings bound to the given command</returns>
|
|
public List<KeyBinding> GetKeyBindings(BindableCommand command)
|
|
{
|
|
List<KeyBinding> ret = new List<KeyBinding>();
|
|
foreach (KeyValuePair<KeyBinding, List<BindableCommand>> item in _boundCommands)
|
|
{
|
|
if (item.Value.Contains(command))
|
|
ret.Add(item.Key);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
internal bool ProcessKey(KeyEventArgs e)
|
|
{
|
|
StopProcessingCommands = false;
|
|
|
|
KeyBinding kb = new KeyBinding(e.KeyCode, e.Modifiers);
|
|
if (!_boundCommands.ContainsKey(kb))
|
|
return false;
|
|
|
|
List<BindableCommand> cmds = _boundCommands[kb];
|
|
if (cmds.Count == 0)
|
|
return false;
|
|
|
|
cmds.Sort(_commandComparer);
|
|
|
|
bool ret = false;
|
|
foreach (BindableCommand cmd in cmds)
|
|
{
|
|
ret |= Execute(cmd);
|
|
|
|
if (StopProcessingCommands)
|
|
return ret;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Removes all key command bindings
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Performing this action will make ScintillaNET virtually unusable until you assign new command bindings.
|
|
/// This removes even basic functionality like arrow keys, common clipboard commands, home/_end, etc.
|
|
/// </remarks>
|
|
public void RemoveAllBindings()
|
|
{
|
|
_boundCommands.Clear();
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Removes all commands bound to a keyboard shortcut
|
|
/// </summary>
|
|
/// <param name="shortcut">Character corresponding to a (keyboard) key to trigger command</param>
|
|
public void RemoveBinding(char shortcut)
|
|
{
|
|
RemoveBinding(Utilities.GetKeys(shortcut), Keys.None);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Removes a keyboard shortcut / command combination
|
|
/// </summary>
|
|
/// <param name="shortcut">Character corresponding to a (keyboard) key to trigger command</param>
|
|
/// <param name="command">Command to execute</param>
|
|
public void RemoveBinding(char shortcut, BindableCommand command)
|
|
{
|
|
RemoveBinding(Utilities.GetKeys(shortcut), Keys.None, command);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Removes all commands bound to a keyboard shortcut
|
|
/// </summary>
|
|
/// <param name="shortcut">Character corresponding to a (keyboard) key to trigger command</param>
|
|
/// <param name="modifiers">Shift, alt, ctrl</param>
|
|
public void RemoveBinding(char shortcut, Keys modifiers)
|
|
{
|
|
RemoveBinding(Utilities.GetKeys(shortcut), modifiers);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Removes a keyboard shortcut / command combination
|
|
/// </summary>
|
|
/// <param name="shortcut">Character corresponding to a (keyboard) key to trigger command</param>
|
|
/// <param name="modifiers">Shift, alt, ctrl</param>
|
|
/// <param name="command">Command to execute</param>
|
|
public void RemoveBinding(char shortcut, Keys modifiers, BindableCommand command)
|
|
{
|
|
RemoveBinding(Utilities.GetKeys(shortcut), modifiers, command);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Removes all commands bound to a keyboard shortcut
|
|
/// </summary>
|
|
/// <param name="shortcut">Key to trigger command</param>
|
|
public void RemoveBinding(Keys shortcut)
|
|
{
|
|
RemoveBinding(shortcut, Keys.None);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Removes a keyboard shortcut / command combination
|
|
/// </summary>
|
|
/// <param name="shortcut">Key to trigger command</param>
|
|
/// <param name="command">Command to execute</param>
|
|
public void RemoveBinding(Keys shortcut, BindableCommand command)
|
|
{
|
|
RemoveBinding(shortcut, Keys.None, command);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Removes all commands bound to a keyboard shortcut
|
|
/// </summary>
|
|
/// <param name="shortcut">Key to trigger command</param>
|
|
/// <param name="modifiers">Shift, alt, ctrl</param>
|
|
public void RemoveBinding(Keys shortcut, Keys modifiers)
|
|
{
|
|
_boundCommands.Remove(new KeyBinding(shortcut, modifiers));
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Removes a keyboard shortcut / command combination
|
|
/// </summary>
|
|
/// <param name="shortcut">Key to trigger command</param>
|
|
/// <param name="modifiers">Shift, alt, ctrl</param>
|
|
/// <param name="command">Command to execute</param>
|
|
public void RemoveBinding(Keys shortcut, Keys modifiers, BindableCommand command)
|
|
{
|
|
KeyBinding kb = new KeyBinding(shortcut, modifiers);
|
|
if (!_boundCommands.ContainsKey(kb))
|
|
return;
|
|
|
|
_boundCommands[kb].Remove(command);
|
|
}
|
|
|
|
|
|
private void ResetAllowDuplicateBindings()
|
|
{
|
|
_allowDuplicateBindings = true;
|
|
}
|
|
|
|
|
|
internal bool ShouldSerialize()
|
|
{
|
|
return ShouldSerializeAllowDuplicateBindings();
|
|
}
|
|
|
|
|
|
private bool ShouldSerializeAllowDuplicateBindings()
|
|
{
|
|
return !_allowDuplicateBindings;
|
|
}
|
|
|
|
#endregion Methods
|
|
|
|
|
|
#region Properties
|
|
|
|
/// <summary>
|
|
/// Gets/Sets if a key combination can be bound to more than one command. (default is true)
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// When set to false only the first command bound to a key combination is kept.
|
|
/// Subsequent requests are ignored.
|
|
/// </remarks>
|
|
public bool AllowDuplicateBindings
|
|
{
|
|
get
|
|
{
|
|
return _allowDuplicateBindings;
|
|
}
|
|
set
|
|
{
|
|
_allowDuplicateBindings = value;
|
|
}
|
|
}
|
|
|
|
#endregion Properties
|
|
|
|
|
|
#region Constructors
|
|
|
|
internal Commands(Scintilla scintilla) : base(scintilla)
|
|
{
|
|
|
|
// Ha Ha Ha Ha all your commands are belong to us!
|
|
NativeScintilla.ClearAllCmdKeys();
|
|
|
|
// The reason we're doing this is because ScintillaNET is going to own
|
|
// all the command bindings. There are two reasons for this: #1 it makes
|
|
// it easier to handle ScintillaNET specific commands, we don't have to
|
|
// do special logic if its a native command vs. ScintillaNET extension.
|
|
|
|
// #2 Scintilla's built in support for commands binding only allows 1
|
|
// command per key combination. Our key handling allows for any number
|
|
// of commands to be bound to a keyboard combination.
|
|
|
|
// Other future enhancements that I want to do in the future are:
|
|
// Visual Studioesque Key/Chord commands like Ctrl+D, w
|
|
|
|
// Binding contexts. This is another CodeRush inspired idea where
|
|
// commands can only execute if a given context is satisfied (or not).
|
|
// Some examples are "At beginning of line", "In comment",
|
|
// "Autocomplete window active", "In Snippet Range".
|
|
|
|
// OK in order for these commands to play nice with each other some of them
|
|
// have to have knowledge of each other AND they have to execute in a certain
|
|
// order.
|
|
|
|
// Since all the native Scintilla Commands already know how to work together
|
|
// properly they all have the same order. But our commands have to execute first
|
|
|
|
_commandComparer.CommandOrder.Add(BindableCommand.AutoCShow, 100);
|
|
_commandComparer.CommandOrder.Add(BindableCommand.AutoCComplete, 100);
|
|
_commandComparer.CommandOrder.Add(BindableCommand.AutoCCancel, 100);
|
|
_commandComparer.CommandOrder.Add(BindableCommand.DoSnippetCheck, 200);
|
|
_commandComparer.CommandOrder.Add(BindableCommand.AcceptActiveSnippets, 200);
|
|
_commandComparer.CommandOrder.Add(BindableCommand.CancelActiveSnippets, 200);
|
|
_commandComparer.CommandOrder.Add(BindableCommand.NextSnippetRange, 200);
|
|
_commandComparer.CommandOrder.Add(BindableCommand.PreviousSnippetRange, 200);
|
|
|
|
AddBinding(Keys.Down , Keys.None, BindableCommand.LineDown);
|
|
AddBinding(Keys.Down , Keys.Shift, BindableCommand.LineDownExtend);
|
|
AddBinding(Keys.Down , Keys.Control, BindableCommand.LineScrollDown);
|
|
AddBinding(Keys.Down , Keys.Alt | Keys.Shift, BindableCommand.LineDownRectExtend);
|
|
AddBinding(Keys.Up , Keys.None, BindableCommand.LineUp);
|
|
AddBinding(Keys.Up , Keys.Shift, BindableCommand.LineUpExtend);
|
|
AddBinding(Keys.Up , Keys.Control, BindableCommand.LineScrollUp);
|
|
AddBinding(Keys.Up , Keys.Alt | Keys.Shift, BindableCommand.LineUpRectExtend);
|
|
AddBinding('[', Keys.Control, BindableCommand.ParaUp);
|
|
AddBinding('[' , Keys.Control | Keys.Shift, BindableCommand.ParaUpExtend);
|
|
AddBinding(']' , Keys.Control, BindableCommand.ParaDown);
|
|
AddBinding(']' , Keys.Control | Keys.Shift, BindableCommand.ParaDownExtend);
|
|
AddBinding(Keys.Left , Keys.None, BindableCommand.CharLeft);
|
|
AddBinding(Keys.Left , Keys.Shift, BindableCommand.CharLeftExtend);
|
|
AddBinding(Keys.Left , Keys.Control, BindableCommand.WordLeft);
|
|
AddBinding(Keys.Left , Keys.Control | Keys.Shift, BindableCommand.WordLeftExtend);
|
|
AddBinding(Keys.Left , Keys.Alt | Keys.Shift, BindableCommand.CharLeftRectExtend);
|
|
AddBinding(Keys.Right , Keys.None, BindableCommand.CharRight);
|
|
AddBinding(Keys.Right , Keys.Shift, BindableCommand.CharRightExtend);
|
|
AddBinding(Keys.Right , Keys.Control, BindableCommand.WordRight);
|
|
AddBinding(Keys.Right , Keys.Control | Keys.Shift, BindableCommand.WordRightExtend);
|
|
AddBinding(Keys.Right , Keys.Alt | Keys.Shift, BindableCommand.CharRightRectExtend);
|
|
AddBinding('/' , Keys.Control, BindableCommand.WordPartLeft);
|
|
AddBinding('/' , Keys.Control | Keys.Shift, BindableCommand.WordPartLeftExtend);
|
|
AddBinding('\\' , Keys.Control, BindableCommand.WordPartRight);
|
|
AddBinding('\\' , Keys.Control | Keys.Shift, BindableCommand.WordPartRightExtend);
|
|
AddBinding(Keys.Home , Keys.None, BindableCommand.VCHome);
|
|
AddBinding(Keys.Home , Keys.Shift, BindableCommand.VCHomeExtend);
|
|
AddBinding(Keys.Home , Keys.Control, BindableCommand.DocumentStart);
|
|
AddBinding(Keys.Home , Keys.Control | Keys.Shift, BindableCommand.DocumentStartExtend);
|
|
AddBinding(Keys.Home , Keys.Alt, BindableCommand.HomeDisplay);
|
|
AddBinding(Keys.Home , Keys.Alt | Keys.Shift, BindableCommand.VCHomeRectExtend);
|
|
AddBinding(Keys.End , Keys.None, BindableCommand.LineEnd);
|
|
AddBinding(Keys.End , Keys.Shift, BindableCommand.LineEndExtend);
|
|
AddBinding(Keys.End , Keys.Control, BindableCommand.DocumentEnd);
|
|
AddBinding(Keys.End , Keys.Control | Keys.Shift, BindableCommand.DocumentEndExtend);
|
|
AddBinding(Keys.End , Keys.Alt, BindableCommand.LineEndDisplay);
|
|
AddBinding(Keys.End , Keys.Alt | Keys.Shift, BindableCommand.LineEndRectExtend);
|
|
AddBinding(Keys.PageUp , Keys.None, BindableCommand.PageUp);
|
|
AddBinding(Keys.PageUp , Keys.Shift, BindableCommand.PageUpExtend);
|
|
AddBinding(Keys.PageUp , Keys.Alt | Keys.Shift, BindableCommand.PageUpRectExtend);
|
|
AddBinding(Keys.PageDown , Keys.None, BindableCommand.PageDown);
|
|
AddBinding(Keys.PageDown , Keys.Shift, BindableCommand.PageDownExtend);
|
|
AddBinding(Keys.PageDown , Keys.Alt | Keys.Shift, BindableCommand.PageDownRectExtend);
|
|
AddBinding(Keys.Delete , Keys.None, BindableCommand.Clear);
|
|
AddBinding(Keys.Delete , Keys.Shift, BindableCommand.Cut);
|
|
AddBinding(Keys.Delete , Keys.Control, BindableCommand.DelWordRight);
|
|
AddBinding(Keys.Delete , Keys.Control | Keys.Shift, BindableCommand.DelLineRight);
|
|
AddBinding(Keys.Insert , Keys.None, BindableCommand.EditToggleOvertype);
|
|
AddBinding(Keys.Insert , Keys.Shift, BindableCommand.Paste);
|
|
AddBinding(Keys.Insert , Keys.Control, BindableCommand.Copy);
|
|
AddBinding(Keys.Escape , Keys.None, BindableCommand.Cancel);
|
|
AddBinding(Keys.Back , Keys.None, BindableCommand.DeleteBack);
|
|
AddBinding(Keys.Back , Keys.Shift, BindableCommand.DeleteBack);
|
|
AddBinding(Keys.Back , Keys.Control, BindableCommand.DelWordLeft);
|
|
AddBinding(Keys.Back , Keys.Alt, BindableCommand.Undo);
|
|
AddBinding(Keys.Back , Keys.Control | Keys.Shift, BindableCommand.DelLineLeft);
|
|
AddBinding(Keys.Z, Keys.Control, BindableCommand.Undo);
|
|
AddBinding(Keys.Y, Keys.Control, BindableCommand.Redo);
|
|
AddBinding(Keys.X, Keys.Control, BindableCommand.Cut);
|
|
AddBinding(Keys.C, Keys.Control, BindableCommand.Copy);
|
|
AddBinding(Keys.V, Keys.Control, BindableCommand.Paste);
|
|
AddBinding(Keys.A, Keys.Control, BindableCommand.SelectAll);
|
|
AddBinding(Keys.Tab , Keys.None, BindableCommand.Tab);
|
|
AddBinding(Keys.Tab , Keys.Shift, BindableCommand.BackTab);
|
|
AddBinding(Keys.Enter , Keys.None, BindableCommand.NewLine);
|
|
AddBinding(Keys.Enter , Keys.Shift, BindableCommand.NewLine);
|
|
AddBinding(Keys.Add , Keys.Control, BindableCommand.ZoomIn);
|
|
AddBinding(Keys.Subtract , Keys.Control, BindableCommand.ZoomOut);
|
|
AddBinding(Keys.Divide, Keys.Control, BindableCommand.SetZoom);
|
|
AddBinding(Keys.L, Keys.Control, BindableCommand.LineCut);
|
|
AddBinding(Keys.L, Keys.Control | Keys.Shift, BindableCommand.LineDelete);
|
|
AddBinding(Keys.T , Keys.Control | Keys.Shift, BindableCommand.LineCopy);
|
|
AddBinding(Keys.T, Keys.Control, BindableCommand.LineTranspose);
|
|
AddBinding(Keys.D, Keys.Control, BindableCommand.SelectionDuplicate);
|
|
AddBinding(Keys.U, Keys.Control, BindableCommand.LowerCase);
|
|
AddBinding(Keys.U, Keys.Control | Keys.Shift, BindableCommand.UpperCase);
|
|
|
|
AddBinding(Keys.Space, Keys.Control, BindableCommand.AutoCShow);
|
|
AddBinding(Keys.Tab, BindableCommand.DoSnippetCheck);
|
|
AddBinding(Keys.Tab, BindableCommand.NextSnippetRange);
|
|
AddBinding(Keys.Tab, Keys.Shift, BindableCommand.PreviousSnippetRange);
|
|
AddBinding(Keys.Escape, BindableCommand.CancelActiveSnippets);
|
|
AddBinding(Keys.Enter, BindableCommand.AcceptActiveSnippets);
|
|
|
|
AddBinding(Keys.P, Keys.Control, BindableCommand.Print);
|
|
AddBinding(Keys.P, Keys.Control | Keys.Shift, BindableCommand.PrintPreview);
|
|
|
|
AddBinding(Keys.F, Keys.Control, BindableCommand.ShowFind);
|
|
AddBinding(Keys.H, Keys.Control, BindableCommand.ShowReplace);
|
|
AddBinding(Keys.F3, BindableCommand.FindNext);
|
|
AddBinding(Keys.F3, Keys.Shift, BindableCommand.FindPrevious);
|
|
AddBinding(Keys.I, Keys.Control, BindableCommand.IncrementalSearch);
|
|
|
|
AddBinding(Keys.Q, Keys.Control, BindableCommand.LineComment);
|
|
AddBinding(Keys.Q, Keys.Control | Keys.Shift, BindableCommand.LineUncomment);
|
|
|
|
AddBinding('-', Keys.Control, BindableCommand.DocumentNavigateBackward);
|
|
AddBinding('-', Keys.Control | Keys.Shift, BindableCommand.DocumentNavigateForward);
|
|
|
|
AddBinding(Keys.J, Keys.Control, BindableCommand.ShowSnippetList);
|
|
|
|
AddBinding(Keys.M, Keys.Control, BindableCommand.DropMarkerDrop);
|
|
AddBinding(Keys.Escape, BindableCommand.DropMarkerCollect);
|
|
|
|
AddBinding(Keys.G, Keys.Control, BindableCommand.ShowGoTo);
|
|
}
|
|
|
|
#endregion Constructors
|
|
|
|
|
|
#region Types
|
|
|
|
private class CommandComparer : IComparer<BindableCommand>
|
|
{
|
|
#region Fields
|
|
|
|
private Dictionary<BindableCommand, int> _commandOrder = new Dictionary<BindableCommand, int>();
|
|
|
|
#endregion Fields
|
|
|
|
|
|
#region Methods
|
|
|
|
public int Compare(BindableCommand x, BindableCommand y)
|
|
{
|
|
return GetCommandOrder(y).CompareTo(GetCommandOrder(x));
|
|
}
|
|
|
|
|
|
private int GetCommandOrder(BindableCommand cmd)
|
|
{
|
|
if (!_commandOrder.ContainsKey(cmd))
|
|
return 0;
|
|
return _commandOrder[cmd];
|
|
}
|
|
|
|
#endregion Methods
|
|
|
|
|
|
#region Properties
|
|
|
|
public Dictionary<BindableCommand, int> CommandOrder
|
|
{
|
|
get
|
|
{
|
|
return _commandOrder;
|
|
}
|
|
set
|
|
{
|
|
_commandOrder = value;
|
|
}
|
|
}
|
|
|
|
#endregion Properties
|
|
}
|
|
|
|
#endregion Types
|
|
}
|
|
}
|