Erfassen des Tastaturereignisses Cmd-C (oder Ctrl-C) aus einer modularen Flex-Anwendung im Browser oder in AIR

Question

Es scheint unmöglich zu sein, das Tastaturereignis zu erfassen, das normalerweise zum Kopieren verwendet wird, wenn eine Flex-Anwendung im Browser oder als AIR-Anwendung ausgeführt wird, vermutlich weil der Browser oder das Betriebssystem es zuerst abfängt.

Gibt es eine Möglichkeit, den Browser oder das Betriebssystem anzuweisen, das Ereignis durchzulassen?

In einem AdvancedDataGrid habe ich zum Beispiel das keyUp-Ereignis auf handleCaseListKeyUp(event) gesetzt, das die folgende Funktion aufruft:

        private function handleCaseListKeyUp(event:KeyboardEvent):void
        {
            var char:String = String.fromCharCode(event.charCode).toUpperCase();

            if (event.ctrlKey && char == "C")
            {
                trace("Ctrl-C");
                copyCasesToClipboard();
                return;
            }

            if (!event.ctrlKey && char == "C")
            {
                trace("C");
                copyCasesToClipboard();
                return;
            }

            // Didn't match event to capture, just drop out.
            trace("charCode: " + event.charCode);
            trace("char: " + char);
            trace("keyCode: " + event.keyCode);
            trace("ctrlKey: " + event.ctrlKey);
            trace("altKey: " + event.altKey);
            trace("shiftKey: " + event.shiftKey);
        }

Bei der Ausführung kann ich nie die Freigabe der Taste "C" erhalten, während ich gleichzeitig die Befehlstaste drücke (die als KeyboardEvent.ctrlKey angezeigt wird). Ich erhalte die folgenden Trace-Ergebnisse:

charCode: 0
char: 
keyCode: 17
ctrlKey: false
altKey: false
shiftKey: false

Wie Sie sehen können, ist das einzige Ereignis, das ich erfassen kann, das Loslassen der Befehlstaste, das Loslassen der Taste "C", während die Befehlstaste gehalten wird, wird nicht einmal gesendet.

Hat jemand erfolgreich die Standard-Tastaturbedienung für Kopieren und Einfügen implementiert?

Soll ich einfach nur die Taste "C" verwenden (wie im Codebeispiel gezeigt) oder eine Kopierschaltfläche zur Verfügung stellen?

Oder muss ich den Listener manuell auf einer höheren Ebene erstellen und das Ereignis in die Eingeweide meiner modularen Anwendung weiterleiten?

Answer 1

Ich habe einen Test durchgeführt, bei dem ich auf Tastenereignisse auf der Bühne lauschte und feststellte, dass ich (auf meinem Mac) control-c, control-v usw. einfach gut erfassen konnte, aber alles, was mit command (der Taste) zu tun hatte, wurde nicht erfasst, bis ich die Befehlstaste losließ, und dann war ctrlKey falsch (auch wenn die Docs sagt, dass ctrlKey für die Befehlstaste auf dem Mac wahr sein sollte), und der charCode war 0. Ziemlich nutzlos, kurz gesagt.

Answer 2

Eine weitere unglaublich ärgerliche Sache, die ich gerade festgestellt habe, ist, dass ctrl-c nicht von event.ctrlKey && event.keyCode = Keyboard.C (oder ... event.charCode == 67 ), müssen Sie stattdessen testen auf charCode o keyCode  unter 3 . Es macht irgendwie Sinn für charCode da ctrl-c ist 3 in der ASCII-Tabelle, aber es macht keinen Sinn für keyCode die die Taste auf der Tastatur darstellen soll, nicht das getippte Zeichen. Das Gleiche gilt für alle anderen Tastenkombinationen (denn jede ctrl-Kombination hat eine ASCII-Entsprechung).

Editar Ich habe einen Fehler im Flex-Fehlersystem zu diesem Thema gefunden: https://bugs.adobe.com/jira/browse/FP-375

Answer 3

Bei mir funktioniert das folgendermaßen:

    private var _ctrlHoldFlag:Boolean = false; 

    // Do something if CTRL was held down and C was pressed
    // Otherwise release the ctrl flag if it was pressed
    public function onKey_Up(event:KeyboardEvent):void {  
        var keycode_c:uint = 67;

        if (_ctrlHoldFlag && event.keyCode == keycode_c)
        {
            //do whatever you need on CTRL-C
        }

        if (event.ctrlKey)
        {
            _ctrlHoldFlag = false;
        }
    }

    // Track ctrl key down press 
    public function onKey_Down(event:KeyboardEvent):void
    {
        if (event.ctrlKey)
        {
            _ctrlHoldFlag = true;
        }
    }

Answer 4

Ich habe eine Lösung für dieses Problem gefunden, die auf der Erfassungssequenz basiert. Wenn Sie z.B. Cmd+A drücken, ist die Sequenz:

• Typ: KEY_DOWN, keyCode 15
• Typ: KEY_UP, keyCode 15
• Typ: KEY_DOWN, keyCode 65

Jedes Mal, wenn Sie keyCode 15 nach unten und dann nach oben erhalten und die nächste Erfassung nach unten ist, können Sie davon ausgehen, dass der Benutzer die Tastenkombination gedrückt hat. Meine Implementierung sieht am Ende so aus:

    protected var lastKeys:Array;
    this.stage.addEventListener(KeyboardEvent.KEY_DOWN, keyHandler, false, 0, true);
    this.stage.addEventListener(KeyboardEvent.KEY_UP, keyHandler, false, 0, true);

    private function getCmdKey(ev:KeyboardEvent):Boolean {
        this.lastKeys.push(ev);
        this.lastKeys = this.lastKeys.splice(Math.max(0, this.lastKeys.length-3), 3);

        if (this.lastKeys.length < 3) return false;

        if (ev.keyCode != 15 && ev.type == KeyboardEvent.KEY_UP) {
            var firstKey:KeyboardEvent = this.lastKeys[0] as KeyboardEvent;
            var secondKey:KeyboardEvent = this.lastKeys[1] as KeyboardEvent;

            if (firstKey.keyCode == 15 && firstKey.type == KeyboardEvent.KEY_DOWN &&
                secondKey.keyCode == 15 && secondKey.type == KeyboardEvent.KEY_UP) {
                    return true;
            }
        }

        return false;
    }

    private function keyHandler(ev:KeyboardEvent):void {
        var cmdKey:Boolean = this.getCmdKey(ev.clone() as KeyboardEvent);
        var ctrlKey:Boolean = ev.ctrlKey || cmdKey;

        if (ctrlKey) {
            if (ev.keyCode == 65) { 
                // ctrl + "a"-- select all!
            }
        }
    }