public MenuItemEntryDiscoveryInfo(string menuItemPath, List <KeyCombination> keys)
{
m_KeyCombinations = keys;
m_MenuItemPath = menuItemPath;
m_ShortcutEntry = new ShortcutEntry(new Identifier(m_MenuItemPath), m_KeyCombinations, null, null, ShortcutType.Menu);
}
public void ExecuteOnce(ShortcutEntry entry)
{
m_UnresolvedConflictPending = false;
Execute(entry);
Cleanup();
}
public void NavigateTo(ShortcutEntry shortcutEntry)
{
SetCategorySelected(FindCategoryFor(shortcutEntry));
selectedEntry = shortcutEntry;
m_ShortcutManagerWindowView.RefreshCategoryList();
m_ShortcutManagerWindowView.RefreshShortcutList();
}
bool DoShortcutEntriesConflict(ShortcutEntry shortcutEntry1, ShortcutEntry shortcutEntry2, IContextManager contextManager)
{
return(contextManager.DoContextsConflict(shortcutEntry1.context, shortcutEntry2.context) &&
string.Equals(shortcutEntry1.tag, shortcutEntry2.tag) &&
(shortcutEntry1.StartsWith(shortcutEntry2.combinations) ||
shortcutEntry2.StartsWith(shortcutEntry1.combinations)));
}
//TODO: find a better place for this logic, Directory maybe?
IList <ShortcutEntry> FindConflictsIfRebound(ShortcutEntry entry, List <KeyCombination> newCombination)
{
var conflictingShortcuts = new List <ShortcutEntry>();
m_Directory.FindPotentialConflicts(entry.context, entry.tag, newCombination, conflictingShortcuts, m_ContextManager);
conflictingShortcuts.Remove(entry);
return(conflictingShortcuts);
}
public MenuItemEntryDiscoveryInfo(string menuItemPath, List <KeyCombination> keys)
{
m_KeyCombinations = keys;
m_MenuItemPath = menuItemPath;
Action <ShortcutArguments> menuAction = (args) => { EditorApplication.ExecuteMenuItem(m_MenuItemPath); };
m_ShortcutEntry = new ShortcutEntry(new Identifier(Discovery.k_MainMenuShortcutPrefix + m_MenuItemPath), m_KeyCombinations, menuAction, null, ShortcutType.Menu);
}
static bool ShortcutEntrySatisfiesContextManager(ShortcutEntry entry)
{
return(m_ContextManager.HasActiveContextOfType(entry.context) &&
// Emulate old play mode shortcut behavior
// * Menu shortcuts are always active
// * Non-menu shortcuts only apply when the game view does not have focus
(!m_ContextManager.playModeContextIsActive ||
entry.type == ShortcutType.Menu));
}
public void Add(ShortcutEntry profileEntry)
{
var existingEntry = m_Entries.SingleOrDefault(entry => entry.identifier.Equals(profileEntry.identifier));
if (existingEntry != null)
{
throw new ArgumentException("This profile already contains an existing entry with matching Identifier!", nameof(profileEntry));
}
m_Entries.Add(new SerializableShortcutEntry(profileEntry));
}
public void ResetToDefault(ShortcutEntry entry)
{
var oldBinding = new ShortcutBinding(entry.combinations);
entry.ResetToDefault();
activeProfile.Remove(entry.identifier);
SaveShortcutProfile(activeProfile);
var newBinding = new ShortcutBinding(entry.combinations);
shortcutBindingChanged?.Invoke(this, entry.identifier, oldBinding, newBinding);
}
void AddEntry(KeyCode keyCode, ShortcutEntry entry)
{
int keyCodeValue = (int)keyCode;
List <ShortcutEntry> entriesForKeyCode = m_IndexedShortcutEntries[keyCodeValue];
if (entriesForKeyCode == null)
{
m_IndexedShortcutEntries[keyCodeValue] = entriesForKeyCode = new List <ShortcutEntry>();
}
entriesForKeyCode.Add(entry);
}
string FindCategoryFor(ShortcutEntry shortcutEntry)
{
foreach (var pair in m_CategoryToEntriesList)
{
var foundId = pair.Value.Find(entry => entry == shortcutEntry);
if (foundId != null)
{
return(pair.Key);
}
}
return(m_AllUnityCommands);
}
void Execute(ShortcutEntry entry)
{
if (entry.type == ShortcutType.Clutch)
{
throw new InvalidOperationException("Clutches cannot be activated through conflict resolution");
}
var args = new ShortcutArguments();
args.context = m_ContextManager.GetContextInstanceOfType(entry.context);
args.stage = ShortcutStage.End;
entry.action(args);
}
void Execute(ShortcutEntry entry)
{
if (entry.type == ShortcutType.Clutch)
{
throw new InvalidOperationException("Clutches cannot be activated through conflict resolution");
}
var entryIndex = m_Entries.IndexOf(entry);
var args = new ShortcutArguments();
args.context = m_Contexts[entryIndex];
args.stage = ShortcutStage.End;
entry.action(args);
}
public void ExecuteAlways(ShortcutEntry entry)
{
m_UnresolvedConflictPending = false;
foreach (var shortcutEntry in m_Entries)
{
if (shortcutEntry != entry)
{
m_ProfileManager.ModifyShortcutEntry(shortcutEntry.identifier, new List <KeyCombination>(0));
}
}
if (entry.type != ShortcutType.Clutch)
{
Execute(entry);
}
Cleanup();
}
bool BelongsToSearch(ShortcutEntry entry)
{
if (!IsSearching())
{
return(true);
}
switch (searchMode)
{
case SearchOption.Name:
return(entry.displayName.IndexOf(m_SerializedState.search, StringComparison.InvariantCultureIgnoreCase) >= 0);
case SearchOption.Binding:
return(entry.StartsWith(m_SerializedState.bindingsSearch));
}
return(false);
}
public bool IsBindingValid(ShortcutEntry shortcut, out string invalidBindingMessage)
{
if (!IsCombinationValid(shortcut.combinations, out invalidBindingMessage))
{
return(false);
}
foreach (var keyCombination in shortcut.combinations)
{
if ((keyCombination.keyCode == KeyCode.Mouse0 || keyCombination.keyCode == KeyCode.Mouse1) && shortcut.context == ContextManager.globalContextType)
{
invalidBindingMessage = $"Binding of global shortcut '{shortcut.displayName}' uses key code {keyCombination.keyCode} that is not allowed for shortcut with this context type";
return(false);
}
}
invalidBindingMessage = null;
return(true);
}
public IEnumerable <ShortcutEntry> GetAllShortcuts()
{
var staticMethodsBindings = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
var methods = EditorAssemblies.GetAllMethodsWithAttribute <ShortcutAttribute>(staticMethodsBindings);
var results = new List <ShortcutEntry>(methods.Count());
foreach (var methodInfo in methods)
{
var attributes = (ShortcutAttribute[])methodInfo.GetCustomAttributes(typeof(ShortcutAttribute), true);
foreach (var attribute in attributes)
{
var shortcutEntry = ShortcutEntry.CreateFromAttribute(methodInfo, attribute);
results.Add(shortcutEntry);
}
}
return(results);
}
void RebindEntry(ShortcutEntry entry, List <KeyCombination> keyCombination)
{
// Ensure we have an active profile, if not create a new one
if (m_ShortcutProfileManager.activeProfile == null)
{
var uniqueProfileId = GetUniqueProfileId();
if (uniqueProfileId == null)
{
Debug.LogWarning("Could not create unique profile id.");
return;
}
m_ShortcutProfileManager.activeProfile = m_ShortcutProfileManager.CreateProfile(uniqueProfileId);
}
m_ShortcutProfileManager.ModifyShortcutEntry(entry.identifier, keyCombination);
UpdateCommandsWithConflicts();
BuildKeyMapBindingStateData();
PopulateShortcutList();
m_ShortcutManagerWindowView.RefreshAll();
}
static void CellGUI(Rect getCellRect, ShortcutEntry item, MyColumns getColumn, ref RowGUIArgs args)
{
switch (getColumn)
{
case MyColumns.Name:
{
GUI.Label(getCellRect, item.displayName);
break;
}
case MyColumns.Type:
{
GUI.Label(getCellRect, item.type.ToString());
break;
}
case MyColumns.Binding:
{
GUI.Label(getCellRect, KeyCombination.SequenceToString(item.combinations));
break;
}
}
}
public void ResetToDefault(ShortcutEntry entry)
{
var newBinding = entry.GetDefaultCombinations();
var conflicts = FindConflictsIfRebound(entry, newBinding);
if (conflicts.Count == 0)
{
m_ShortcutProfileManager.ResetToDefault(entry);
}
else
{
var howToHandle = m_ShortcutManagerWindowView.HandleRebindWillCreateConflict(entry, newBinding, conflicts);
switch (howToHandle)
{
case RebindResolution.DoNotRebind:
break;
case RebindResolution.CreateConflict:
m_ShortcutProfileManager.ResetToDefault(entry);
break;
case RebindResolution.UnassignExistingAndBind:
foreach (var conflictEntry in conflicts)
{
RebindEntry(conflictEntry, new List <KeyCombination>());
}
m_ShortcutProfileManager.ResetToDefault(entry);
break;
default:
throw new Exception("Unhandled enum case");
}
}
m_ShortcutManagerWindowView.RefreshShortcutList();
}
public ShortcutAttributeEntryInfo(MethodInfo methodInfo, ShortcutBaseAttribute attribute)
{
m_MethodInfo = methodInfo;
m_ShortcutEntry = attribute.CreateShortcutEntry(m_MethodInfo);
}
static bool ShortcutEntryMatchesAnyContext(ShortcutEntry entry)
{
m_ShortcutEntryContext = entry.context;
return(m_ShortcutEntryContextList == null || m_ShortcutEntryContextList.Any(ShortcutEntryMatchesContext));
}
public void ShortcutEntrySelected(ShortcutEntry entry)
{
selectedEntry = entry;
}
bool CurrentContextManagerHasPriorityContextFor(ShortcutEntry entry)
{
return(m_CurrentContextManager.HasPriorityContextOfType(entry.context));
}
static bool ShortcutStartsWithCombinationSequenceAndSatisfiesPredicate(ShortcutEntry entry)
{
return(entry.StartsWith(m_CombinationSequence) && (m_Predicate == null || m_Predicate(entry)));
}
bool ShortcutFullyMatchesKeyCombination(ShortcutEntry shortcutEntry)
{
return(shortcutEntry.FullyMatches(m_KeyCombinationSequence));
}
static bool IsGlobalContext(ShortcutEntry entry)
{
return(entry.context == ContextManager.globalContextType);
}
public void DragEntryAndDropIntoKey(KeyCode keyCode, EventModifiers eventModifier, ShortcutEntry entry)
{
if (!CanEntryBeAssignedToKey(keyCode, eventModifier, entry))
{
throw new InvalidOperationException("This would create a conflict");
}
var keyCombination = new List <KeyCombination>();
keyCombination.Add(KeyCombination.FromKeyboardInput(keyCode, eventModifier));
RebindEntry(entry, keyCombination);
}
public bool IsEntryPartOfConflict(ShortcutEntry shortcutEntry)
{
return(m_CategoryToEntriesList[m_CommandsWithConflicts].Contains(shortcutEntry));
}
public bool CanEntryBeAssignedToKey(KeyCode keyCode, EventModifiers eventModifier, ShortcutEntry entry)
{
if (!m_BindingValidator.IsBindingValid(keyCode))
{
return(false);
}
var keycombination = KeyCombination.FromKeyboardInput(keyCode, eventModifier);
List <ShortcutEntry> entries;
if (m_KeyBindingRootToBoundEntries.TryGetValue(keycombination, out entries))
{
foreach (var boundEntry in entries)
{
if (IsGlobalContext(entry))
{
return(false);
}
if (boundEntry.context.IsAssignableFrom(entry.context) || entry.context.IsAssignableFrom(boundEntry.context))
{
return(false);
}
}
}
return(true);
}
