Scorciatoie da tastiera di cacao in dialogo senza un menu di modifica
https://stackoverflow.com/questions/970707
-
13-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Ho un'applicazione LSUIElement che visualizza un elemento di stato barra dei menu. L'applicazione può visualizzare una finestra di dialogo che contiene un campo di testo.
Se l'utente fa clic destro / Controllo-clic sul campo di testo, viene visualizzato un menu che consente taglia, copia, incolla, ecc, tuttavia, il Comando-X di serie, Comando-C, e Command-V scorciatoie da tastiera non lo fanno lavorare nel campo. Presumo che questo è perché la mia domanda non fornisce un menu Modifica con queste scorciatoie definite.
Ho provato ad aggiungere una voce di menu Modifica al menu di mia domanda, come suggerito nel nave Alcuni Codice blog, ma che non ha funzionato. Le voci di menu nel menu Modifica possono essere utilizzati, ma le scorciatoie da tastiera ancora non funzionano.
Posso immaginare alcuni modi per hackerare la gestione della tastiera, ma c'è un modo "raccomandato" per fare questo lavoro?
(Per i dettagli su l'applicazione, vedi barra dei menu Countdown .)
domanda Correlati: copia / incolla non funziona nella finestra modale
Soluzione 2
Che cosa ha funzionato per me è stato utilizzando The View Soluzione presentato in Copia e Scorciatoie da tastiera Incolla a CocoaRocket.
In sostanza, questo significa sottoclassi NSTextField e performKeyEquivalent: prioritario.
Aggiornamento: Il sito CocoaRocket è apparentemente scomparso. Ecco il link Internet Archive: http: / /web.archive.org/web/20100126000339/http://www.cocoarocket.com/articles/copypaste.html
Modifica : il codice Swift si presenta così
class Editing: NSTextField {
private let commandKey = NSEventModifierFlags.CommandKeyMask.rawValue
private let commandShiftKey = NSEventModifierFlags.CommandKeyMask.rawValue | NSEventModifierFlags.ShiftKeyMask.rawValue
override func performKeyEquivalent(event: NSEvent) -> Bool {
if event.type == NSEventType.KeyDown {
if (event.modifierFlags.rawValue & NSEventModifierFlags.DeviceIndependentModifierFlagsMask.rawValue) == commandKey {
switch event.charactersIgnoringModifiers! {
case "x":
if NSApp.sendAction(Selector("cut:"), to:nil, from:self) { return true }
case "c":
if NSApp.sendAction(Selector("copy:"), to:nil, from:self) { return true }
case "v":
if NSApp.sendAction(Selector("paste:"), to:nil, from:self) { return true }
case "z":
if NSApp.sendAction(Selector("undo:"), to:nil, from:self) { return true }
case "a":
if NSApp.sendAction(Selector("selectAll:"), to:nil, from:self) { return true }
default:
break
}
}
else if (event.modifierFlags.rawValue & NSEventModifierFlags.DeviceIndependentModifierFlagsMask.rawValue) == commandShiftKey {
if event.charactersIgnoringModifiers == "Z" {
if NSApp.sendAction(Selector("redo:"), to:nil, from:self) { return true }
}
}
}
return super.performKeyEquivalent(event)
}
}
Modifica Il codice Swift 3 è simile al seguente
class Editing: NSTextView {
private let commandKey = NSEventModifierFlags.command.rawValue
private let commandShiftKey = NSEventModifierFlags.command.rawValue | NSEventModifierFlags.shift.rawValue
override func performKeyEquivalent(with event: NSEvent) -> Bool {
if event.type == NSEventType.keyDown {
if (event.modifierFlags.rawValue & NSEventModifierFlags.deviceIndependentFlagsMask.rawValue) == commandKey {
switch event.charactersIgnoringModifiers! {
case "x":
if NSApp.sendAction(#selector(NSText.cut(_:)), to:nil, from:self) { return true }
case "c":
if NSApp.sendAction(#selector(NSText.copy(_:)), to:nil, from:self) { return true }
case "v":
if NSApp.sendAction(#selector(NSText.paste(_:)), to:nil, from:self) { return true }
case "z":
if NSApp.sendAction(Selector(("undo:")), to:nil, from:self) { return true }
case "a":
if NSApp.sendAction(#selector(NSResponder.selectAll(_:)), to:nil, from:self) { return true }
default:
break
}
}
else if (event.modifierFlags.rawValue & NSEventModifierFlags.deviceIndependentFlagsMask.rawValue) == commandShiftKey {
if event.charactersIgnoringModifiers == "Z" {
if NSApp.sendAction(Selector(("redo:")), to:nil, from:self) { return true }
}
}
}
return super.performKeyEquivalent(with: event)
}
}
Altri suggerimenti
Il miglioramento su quella soluzione CocoaRocket:
Il seguente salva dover sottoclasse NSTextField e ricordando di utilizzare la sottoclasse in tutta l'applicazione; essa consentirà inoltre copiare, incollare e gli amici per gli altri soccorritori che li gestiscono, ad esempio. NSTextView.
Mettere questo in una sottoclasse di NSApplication e alterare la classe principale nel vostro Info.plist di conseguenza.
- (void) sendEvent:(NSEvent *)event {
if ([event type] == NSKeyDown) {
if (([event modifierFlags] & NSDeviceIndependentModifierFlagsMask) == NSCommandKeyMask) {
if ([[event charactersIgnoringModifiers] isEqualToString:@"x"]) {
if ([self sendAction:@selector(cut:) to:nil from:self])
return;
}
else if ([[event charactersIgnoringModifiers] isEqualToString:@"c"]) {
if ([self sendAction:@selector(copy:) to:nil from:self])
return;
}
else if ([[event charactersIgnoringModifiers] isEqualToString:@"v"]) {
if ([self sendAction:@selector(paste:) to:nil from:self])
return;
}
else if ([[event charactersIgnoringModifiers] isEqualToString:@"z"]) {
if ([self sendAction:@selector(undo:) to:nil from:self])
return;
}
else if ([[event charactersIgnoringModifiers] isEqualToString:@"a"]) {
if ([self sendAction:@selector(selectAll:) to:nil from:self])
return;
}
}
else if (([event modifierFlags] & NSDeviceIndependentModifierFlagsMask) == (NSCommandKeyMask | NSShiftKeyMask)) {
if ([[event charactersIgnoringModifiers] isEqualToString:@"Z"]) {
if ([self sendAction:@selector(redo:) to:nil from:self])
return;
}
}
}
[super sendEvent:event];
}
// Blank Selectors to silence Xcode warnings: 'Undeclared selector undo:/redo:'
- (IBAction)undo:(id)sender {}
- (IBAction)redo:(id)sender {}
Ho avuto lo stesso problema come voi, e penso che sono riuscito a trovare una soluzione più semplice. Hai solo bisogno di uscire dal menu principale originale in MainMenu.xib - non verrà visualizzato, ma tutte le azioni saranno gestiti correttamente. Il trucco è che ha bisogno di essere quello originale, se è sufficiente trascinare un nuovo NSMenu dalla libreria, l'applicazione non lo riconoscerà come menu principale e non ho idea di come contrassegnare come tale (se si deseleziona LSUIElement, vedrai che non verrà visualizzato nella parte superiore se non è quello originale). Se hai già eliminato, è possibile creare una nuova applicazione di esempio e trascinare un menu dal suo NIB, che funziona anche.
Ho migliorato la soluzione di Adrian a lavorare quando Caps Lock è attivo così:
- (void)sendEvent:(NSEvent *)event
{
if (event.type == NSKeyDown)
{
NSString *inputKey = [event.charactersIgnoringModifiers lowercaseString];
if ((event.modifierFlags & NSDeviceIndependentModifierFlagsMask) == NSCommandKeyMask ||
(event.modifierFlags & NSDeviceIndependentModifierFlagsMask) == (NSCommandKeyMask | NSAlphaShiftKeyMask))
{
if ([inputKey isEqualToString:@"x"])
{
if ([self sendAction:@selector(cut:) to:nil from:self])
return;
}
else if ([inputKey isEqualToString:@"c"])
{
if ([self sendAction:@selector(copy:) to:nil from:self])
return;
}
else if ([inputKey isEqualToString:@"v"])
{
if ([self sendAction:@selector(paste:) to:nil from:self])
return;
}
else if ([inputKey isEqualToString:@"z"])
{
if ([self sendAction:NSSelectorFromString(@"undo:") to:nil from:self])
return;
}
else if ([inputKey isEqualToString:@"a"])
{
if ([self sendAction:@selector(selectAll:) to:nil from:self])
return;
}
}
else if ((event.modifierFlags & NSDeviceIndependentModifierFlagsMask) == (NSCommandKeyMask | NSShiftKeyMask) ||
(event.modifierFlags & NSDeviceIndependentModifierFlagsMask) == (NSCommandKeyMask | NSShiftKeyMask | NSAlphaShiftKeyMask))
{
if ([inputKey isEqualToString:@"z"])
{
if ([self sendAction:NSSelectorFromString(@"redo:") to:nil from:self])
return;
}
}
}
[super sendEvent:event];
}
Thomas Kilian a Swift 3.
private let commandKey = NSEventModifierFlags.command.rawValue
private let commandShiftKey = NSEventModifierFlags.command.rawValue | NSEventModifierFlags.shift.rawValue
override func performKeyEquivalent(with event: NSEvent) -> Bool {
if event.type == NSEventType.keyDown {
if (event.modifierFlags.rawValue & NSEventModifierFlags.deviceIndependentFlagsMask.rawValue) == commandKey {
switch event.charactersIgnoringModifiers! {
case "x":
if NSApp.sendAction(#selector(NSText.cut(_:)), to:nil, from:self) { return true }
case "c":
if NSApp.sendAction(#selector(NSText.copy(_:)), to:nil, from:self) { return true }
case "v":
if NSApp.sendAction(#selector(NSText.paste(_:)), to:nil, from:self) { return true }
case "z":
if NSApp.sendAction(Selector(("undo:")), to:nil, from:self) { return true }
case "a":
if NSApp.sendAction(#selector(NSResponder.selectAll(_:)), to:nil, from:self) { return true }
default:
break
}
}
else if (event.modifierFlags.rawValue & NSEventModifierFlags.deviceIndependentFlagsMask.rawValue) == commandShiftKey {
if event.charactersIgnoringModifiers == "Z" {
if NSApp.sendAction(Selector(("redo:")), to:nil, from:self) { return true }
}
}
}
return super.performKeyEquivalent(with: event)
}
Ecco una guida rapida passo-passo per la rapida, sulla base delle ottime risposte da parte @Adrian, Travis B e Thomas Kilian.
L'obiettivo sarà quello di sottoclasse il NSApplication, al posto del NSTextField. Dopo aver creato questa classe, non collegarlo nel vostro ambiente "Classe principale" delle Info.plist, come affermato da Adrian. A differenza delle persone Objective-C, si swiftlers dovranno aggiungere un prefisso aggiuntivo alla configurazione principalClass. Quindi, perché il mio progetto si chiama "pippo", ho intenzione di impostare "Class Principal" a "Foo.MyApplication". Si otterrà un errore di runtime "Class MyApplication non trovato" in caso contrario.
I contenuti di MyApplication recitano (copiato e adattato da tutte le risposte date finora)
import Cocoa
class MyApplication: NSApplication {
override func sendEvent(event: NSEvent) {
if event.type == NSEventType.KeyDown {
if (event.modifierFlags & NSEventModifierFlags.DeviceIndependentModifierFlagsMask == NSEventModifierFlags.CommandKeyMask) {
switch event.charactersIgnoringModifiers!.lowercaseString {
case "x":
if NSApp.sendAction(Selector("cut:"), to:nil, from:self) { return }
case "c":
if NSApp.sendAction(Selector("copy:"), to:nil, from:self) { return }
case "v":
if NSApp.sendAction(Selector("paste:"), to:nil, from:self) { return }
case "z":
if NSApp.sendAction(Selector("undo:"), to:nil, from:self) { return }
case "a":
if NSApp.sendAction(Selector("selectAll:"), to:nil, from:self) { return }
default:
break
}
}
else if (event.modifierFlags & NSEventModifierFlags.DeviceIndependentModifierFlagsMask == (NSEventModifierFlags.CommandKeyMask | NSEventModifierFlags.ShiftKeyMask)) {
if event.charactersIgnoringModifiers == "Z" {
if NSApp.sendAction(Selector("redo:"), to:nil, from:self) { return }
}
}
}
return super.sendEvent(event)
}
}
Swift 4.2 per soluzione Thomas Kilian
class MTextField: NSSecureTextField {
private let commandKey = NSEvent.ModifierFlags.command.rawValue
private let commandShiftKey = NSEvent.ModifierFlags.command.rawValue | NSEvent.ModifierFlags.shift.rawValue
override func performKeyEquivalent(with event: NSEvent) -> Bool {
if event.type == NSEvent.EventType.keyDown {
if (event.modifierFlags.rawValue & NSEvent.ModifierFlags.deviceIndependentFlagsMask.rawValue) == commandKey {
switch event.charactersIgnoringModifiers! {
case "x":
if NSApp.sendAction(#selector(NSText.cut(_:)), to:nil, from:self) { return true }
case "c":
if NSApp.sendAction(#selector(NSText.copy(_:)), to:nil, from:self) { return true }
case "v":
if NSApp.sendAction(#selector(NSText.paste(_:)), to:nil, from:self) { return true }
case "z":
if NSApp.sendAction(Selector(("undo:")), to:nil, from:self) { return true }
case "a":
if NSApp.sendAction(#selector(NSResponder.selectAll(_:)), to:nil, from:self) { return true }
default:
break
}
}
else if (event.modifierFlags.rawValue & NSEvent.ModifierFlags.deviceIndependentFlagsMask.rawValue) == commandShiftKey {
if event.charactersIgnoringModifiers == "Z" {
if NSApp.sendAction(Selector(("redo:")), to:nil, from:self) { return true }
}
}
}
return super.performKeyEquivalent(with: event)
}
}
Gli spiego che cosa ha funzionato per me in XCode 8 / Swift 3.
Ho creato MyApplication.swift dentro la mia MyApp cartella di progetto:
import Foundation
import Cocoa
class MyApplication: NSApplication {
override func sendEvent(_ event: NSEvent) {
if event.type == NSEventType.keyDown {
if (event.modifierFlags.contains(NSEventModifierFlags.command)) {
switch event.charactersIgnoringModifiers!.lowercased() {
case "x":
if NSApp.sendAction(#selector(NSText.cut(_:)), to:nil, from:self) { return }
case "c":
if NSApp.sendAction(#selector(NSText.copy(_:)), to:nil, from:self) { return }
case "v":
if NSApp.sendAction(#selector(NSText.paste(_:)), to:nil, from:self) { return }
case "a":
if NSApp.sendAction(#selector(NSText.selectAll(_:)), to:nil, from:self) { return }
default:
break
}
}
}
return super.sendEvent(event)
}
}
Quindi modificare la Info.plist Principal class a MyApp.MyApplication. Costruire ed eseguire per verificare che i miei campi di testo e punti di vista del testo hanno il supporto per Cmd + X, Cmd + C, Cmd + V e Cmd + A.
Non c'è bisogno di aggiungere una nuova classe, l'estensione o realmente alcun codice a tutti.
- Basta aggiungere un nuovo MenuItems in uno dei vostri menu e il nome li 'Copia', 'Cut' e 'Incolla'.
- Aggiungi i tasti di scelta rapida corrette per ogni voce.
- Control + trascina per collegarli fino ai metodi corrispondenti elencati sotto prima responder.
Il bonus è che le voci non sono nascoste dai vostri utenti, e questo richiede meno tempo che la creazione di una nuova classe e la riassegnazione tutti i campi di testo esistenti ad esso.
Xcode10 / Swift 4.2 soluzione:
import Cocoa
extension NSTextView {
override open func performKeyEquivalent(with event: NSEvent) -> Bool {
let commandKey = NSEvent.ModifierFlags.command.rawValue
let commandShiftKey = NSEvent.ModifierFlags.command.rawValue | NSEvent.ModifierFlags.shift.rawValue
if event.type == NSEvent.EventType.keyDown {
if (event.modifierFlags.rawValue & NSEvent.ModifierFlags.deviceIndependentFlagsMask.rawValue) == commandKey {
switch event.charactersIgnoringModifiers! {
case "x":
if NSApp.sendAction(#selector(NSText.cut(_:)), to:nil, from:self) { return true }
case "c":
if NSApp.sendAction(#selector(NSText.copy(_:)), to:nil, from:self) { return true }
case "v":
if NSApp.sendAction(#selector(NSText.paste(_:)), to:nil, from:self) { return true }
case "z":
if NSApp.sendAction(Selector(("undo:")), to:nil, from:self) { return true }
case "a":
if NSApp.sendAction(#selector(NSResponder.selectAll(_:)), to:nil, from:self) { return true }
default:
break
}
} else if (event.modifierFlags.rawValue & NSEvent.ModifierFlags.deviceIndependentFlagsMask.rawValue) == commandShiftKey {
if event.charactersIgnoringModifiers == "Z" {
if NSApp.sendAction(Selector(("redo:")), to:nil, from:self) { return true }
}
}
}
return super.performKeyEquivalent(with: event)
}
}
Just circa 1 ora fa mi sono imbattuto sullo stesso problema. Non è necessario codificare qualsiasi cosa. Potrei farlo in Interface Builder:
- Crea un menu (ad esempio, "Edit"), che contiene le voci Taglia / Copia / Incolla del menu
- Aggiungi il keyEquivalent per la chiave CMD al menu "Modifica" (non so, se questo è realmente necessario, ho solo copiato la struttura da un altro progetto)
- Aggiungi il KeyEquivalents a queste voci di menu (CMD + X e così via)
- Collegamento di funzioni
FirstResponder,cut:ecopy:delpaste:alle voci di menu corrispondenti
Che ha lavorato per me. Purtroppo questo (default) comportamento non sembra funzionare quando si nasconde il menu "Modifica" (appena provato).
Ecco la risposta di Travis' come C # per l'uso con Xamarin.Mac:
public override bool PerformKeyEquivalent (AppKit.NSEvent e)
{
if (e.Type == NSEventType.KeyDown) {
var inputKey = e.CharactersIgnoringModifiers.ToLower ();
if ( (e.ModifierFlags & NSEventModifierMask.DeviceIndependentModifierFlagsMask) == NSEventModifierMask.CommandKeyMask
|| (e.ModifierFlags & NSEventModifierMask.DeviceIndependentModifierFlagsMask) == (NSEventModifierMask.CommandKeyMask | NSEventModifierMask.AlphaShiftKeyMask)) {
switch (inputKey) {
case "x":
NSApplication.SharedApplication.SendAction (new Selector ("cut:"), null, this);
return true;
case "c":
NSApplication.SharedApplication.SendAction (new Selector ("copy:"), null, this);
return true;
case "v":
NSApplication.SharedApplication.SendAction (new Selector ("paste:"), null, this);
return true;
case "z":
NSApplication.SharedApplication.SendAction (new Selector ("undo:"), null, this);
return true;
case "a":
NSApplication.SharedApplication.SendAction (new Selector ("selectAll:"), null, this);
return true;
}
} else if ( (e.ModifierFlags & NSEventModifierMask.DeviceIndependentModifierFlagsMask) == (NSEventModifierMask.CommandKeyMask | NSEventModifierMask.ShiftKeyMask)
|| (e.ModifierFlags & NSEventModifierMask.DeviceIndependentModifierFlagsMask) == (NSEventModifierMask.CommandKeyMask | NSEventModifierMask.ShiftKeyMask | NSEventModifierMask.AlphaShiftKeyMask)) {
switch (inputKey) {
case "z":
NSApplication.SharedApplication.SendAction (new Selector ("redo:"), null, this);
return true;
}
}
}
return base.PerformKeyEquivalent(e);
}
In base a risposta di Thomas Kilian, si può effettivamente creare un'estensione per NSTextField
let commandKey = NSEvent.ModifierFlags.command.rawValue
let commandShiftKey = NSEvent.ModifierFlags.command.rawValue | NSEvent.ModifierFlags.shift.rawValue
extension NSTextField {
func performEditingKeyEquivalent(with event: NSEvent) -> Bool {
guard event.type == NSEvent.EventType.keyDown else { return false }
if (event.modifierFlags.rawValue & NSEvent.ModifierFlags.deviceIndependentFlagsMask.rawValue) == commandKey {
if let character = event.charactersIgnoringModifiers {
switch character {
case "x":
if NSApp.sendAction(#selector(NSText.cut(_:)), to: nil, from: self) { return true }
case "c":
if NSApp.sendAction(#selector(NSText.copy(_:)), to: nil, from: self) { return true }
case "v":
if NSApp.sendAction(#selector(NSText.paste(_:)), to: nil, from: self) { return true }
case "z":
if NSApp.sendAction(Selector(("undo:")), to: nil, from: self) { return true }
case "a":
if NSApp.sendAction(#selector(NSResponder.selectAll(_:)), to: nil, from: self) { return true }
default:
break
}
}
} else if (event.modifierFlags.rawValue & NSEvent.ModifierFlags.deviceIndependentFlagsMask.rawValue) == commandShiftKey {
if event.charactersIgnoringModifiers == "Z" {
if NSApp.sendAction(Selector(("redo:")), to: nil, from: self) { return true }
}
}
return false
}
}
Nell'esempio followingg, si può effettivamente sostituire NSTextField con una delle caratteristiche NSTextField ereditare classi (ad esempio NSSearchField, NSSecureTextField) per avere la nuova funzionalità
class SearchField: NSTextField {
override func performKeyEquivalent(with event: NSEvent) -> Bool {
if performEditingKeyEquivalent(with: event) {
return true
}
return super.performEditingKeyEquivalent(with: event)
}
}
Grazie per questa soluzione! Mi ha aiutato molto, così ho deciso di contribuire un po 'di codice nella speranza che aiuta a qualcun altro. La soluzione suggerita sopra ha funzionato perfettamente dopo ho convertito a Swift 4.2. Ho poi refactoring del codice un po '. Penso che questo sia un po 'più pulito. Questo è compatibile con Swift 4.2:
// NSEventExtensions.swift
import AppKit
extension NSEvent {
func containsKeyModifierFlags(_ flags: NSEvent.ModifierFlags) -> Bool {
switch modifierFlags.intersection(.deviceIndependentFlagsMask) {
case [flags]: return true
default: return false
}
}
}
// SearchFiled.swift
import AppKit
import Carbon
final class SearchField: NSSearchField {
override func performKeyEquivalent(with event: NSEvent) -> Bool {
switch event.type {
case .keyDown: return performKeyDownEquivalent(with: event)
default: return super.performKeyEquivalent(with: event)
}
}
// MARK: - private
private func performKeyDownEquivalent(with event: NSEvent) -> Bool {
if event.containsKeyModifierFlags(.command) {
switch Int(event.keyCode) {
case kVK_ANSI_X: return NSApp.sendAction(#selector(NSText.cut(_:)), to: nil, from: self)
case kVK_ANSI_C: return NSApp.sendAction(#selector(NSText.copy(_:)), to: nil, from: self)
case kVK_ANSI_V: return NSApp.sendAction(#selector(NSText.paste(_:)), to: nil, from: self)
case kVK_ANSI_Z: return NSApp.sendAction(Selector(("undo:")), to: nil, from: self)
case kVK_ANSI_A: return NSApp.sendAction(#selector(NSResponder.selectAll(_:)), to: nil, from: self)
default: break
}
} else if event.containsKeyModifierFlags([.command, .shift]) {
switch Int(event.keyCode) {
case kVK_ANSI_Z: return NSApp.sendAction(Selector(("redo:")), to: nil, from: self)
default: break
}
}
return false
}
}
La soluzione di Adrian è buona, ma meglio penso di utilizzare un'istruzione switch piuttosto che tutte quelle confronti di stringhe, per esempio:.
uint const modifierCode = (theEvent.modifierFlags & NSDeviceIndependentModifierFlagsMask);
BOOL usingModifiers = ( modifierCode != 0 );
//BOOL const usingShiftKey = ((theEvent.modifierFlags & NSShiftKeyMask) != 0);
//BOOL const usingCommandKey = ((theEvent.modifierFlags & NSCommandKeyMask) != 0);
NSString * ch = [theEvent charactersIgnoringModifiers];
if ( ( usingModifiers ) && ( ch.length == 1 ) ) switch ( [ch characterAtIndex:0] )
{
case 'x':
if ( modifierCode == NSCommandKeyMask ) [m cut]; // <-- m = model
break;
case 'c':
if ( modifierCode == NSCommandKeyMask ) [m copy];
break;
case 'v':
if ( modifierCode == NSCommandKeyMask ) [m paste];
break;
case 'z':
if ( modifierCode == NSCommandKeyMask ) [m undo];
break;
case 'Z':
if ( modifierCode == ( NSCommandKeyMask | NSShiftKeyMask ) ) [m redo];
break;
default: // etc.
break;
}
else switch ( theEvent.keyCode ) // <-- for independent keycodes!
{
case kVK_Home:
[m moveToBeginningOfDocument:nil];
break;
case kVK_End: // etc!
