Shortcut Klasse

[beachmeat]

Aloha,

hier haben wir eine Klasse, welche Tastenshortcuts frisst, und eine angegebene Funktion aufruft bei erfülltem Shortcut, und gewünschte Parameter übergibt.
Die Anzahl an Keys des Shortcuts ist dabei beliebig.
Beim Testen in der Entwicklungsumgebung Tastenkombinationen ausschalten (Steuerung > Tastenkombinationen deaktivieren)

function ShortCut()
{
}
 
o = ShortCut.prototype
 
o.init = function()
{
        this.keysDown   = {}            // Hier werden die aktuell gedrückten Keys reingeschrieben
        
        this.keys     = arguments[0].keys.sort();      // Meine ShortcutKeys
        this.func     = arguments[0].func;      // Die Funktion welche bei Shortcut aufgerufen wird.
        this.scope   = arguments[0].scope;            // Wo die aufgerufen werden soll
        this.passedArgs     = arguments[0].passedArgs;    // Mit welchen Argumenten
        
        this.listen();
}
 
o.listen = function()
{
        this.kl = {}
        this.kl.ref         = this
        this.kl.onKeyDown   = function()
        {
                this.ref.addKey(Key.getCode())
        }
        this.kl.onKeyUp = function()
        {
                this.ref.remKey(Key.getCode())
        }
        
        Key.addListener(this.kl)
}
 
o.addKey = function(code)
{
        if (!this.keysDown[code])
        {
                this.keysDown[code] = true
                this.checkKeys()
        }
        
}
 
o.remKey = function(code)
{
        if (this.keysDown[code])
        {
                delete this.keysDown[code]
    this.checkKeys()
        }
}
 
o.checkKeys = function()
{
        var tArr = []
        for(var i in this.keysDown)
        {
                tArr.push(i)
        }
        tArr.sort()
        if(tArr.toString() == this.keys.toString())
        this.action()
}
 
o.action = function()
{
        this.scope[this.func].apply(this.scope,this.passedArgs);
}
// __________________________________________________
 
 
 
 
// Die Funktion die aufgerufen wird in unserem Beispiel bei Shortcut
fObj = {}
fObj.testemermol = function(a,b,c,d)
{
        trace(a + "-" + b + "-" + c + "-" + d);
}
 
// Das Arguments Object
var obj = {}
 
obj.keys       = [17,65]  //Strg + A
obj.func       = "testemermol";
obj.scope      = fObj;
obj.passedArgs      = ["test",1,2,3];
 
// Shortcut
sc = new ShortCut();
sc.init(obj) 

[bokel]

Sehr praktisch !

Noch praktischer wäre es vielleicht,
wenn man mehrere Shortcuts
auf einmal handeln könnte

Wer wagt sich dran ?

mfg r.

[beachmeat]

Hmm - man kann ja einfach mehrere Instanzen erstellen - aber ok, das liesse sich wohl problemlos machen

[bokel]

Stimmt auch wieder

mfg r.

[kelor]

hübsch...gefällt mir...
ein weiterer beweis, dass man kreativität noch ne menge neuer sachen machen kann...

greetz

kelor

[beachmeat]

hab oben das apply nochma geändert - muss natürlich "this.scope" anstatt "null" sein, um Methoden aufzurufen.
Auch müssen noch die Parameter bei Bedarf zur Laufzeit ausgewertet werden.

function ShortCut()
{
}
 
o = ShortCut.prototype
 
o.init = function()
{
    this.keysDown   = {}              // Hier werden die aktuell gedrückten Keys reingeschrieben
    
    this.keys   = arguments[0].keys.sort();        // Meine ShortcutKeys
    this.func   = arguments[0].func;         // Die Funktion welche bei Shortcut aufgerufen wird.
    this.scope  = arguments[0].scope;            // Wo die aufgerufen werden soll
    this.passedArgs = arguments[0].passedArgs;      // Mit welchen Argumenten
 
    this.listen();
}
 
o.listen = function()
{
    this.kl = {}
    this.kl.ref         = this
    this.kl.onKeyDown   = function()
    {
        trace(Key.getCode())
        this.ref.addKey(Key.getCode())  
    }
    this.kl.onKeyUp = function()
    {
        this.ref.remKey(Key.getCode())  
    }
    
    Key.addListener(this.kl)
}
 
o.addKey = function(code)
{
    if (!this.keysDown[code])
    {
        this.keysDown[code] = true
        this.checkKeys()
    }
    
}
 
o.remKey = function(code)
{
    if (this.keysDown[code])
    {
        delete this.keysDown[code]
    }
}
 
o.checkKeys = function()
{
    var tArr = []
    for(var i in this.keysDown)
    {
        tArr.push(i)
    }
    tArr.sort()
    if(tArr.toString() == this.keys.toString())
    this.action()
}
 
o.action = function()
{
    argArr = [];
    while(var i=0; i<this.passedArgs.length; i++)
    {
        argArr[i] = this.passedArgs[i].evaluate ? eval(this.passedArgs[i].arg) : this.passedArgs[i].arg
    }
 
    this.scope[this.func].apply(this.scope,argArr);
} 

Der veränderte Aufruf sieht so aus:

// NEW NODE
var obj = {}
 
obj.keys    = [17,78]      //Strg + N
obj.func    = "newNode";
obj.scope   = _global[menuName];
obj.passedArgs  = [{arg:"_root.input.text", evaluate:true},{arg:"item", evaluate:false}];
 
// Shortcut
scNewNode = new ShortCut();
scNewNode.init(obj) 

Wenn man einen Wert also zur Laufzeit auswerten will, als String übergeben , und evaluate = true

[Madokan]

Kann mich der Meinung der Jungs nur anschliessen. Bin sicher da hast einigen eine Freude gemacht. Im Offline Bereich wäre die Klasse sicher gut zu gebrauchen, oder man kombiniert sie mit borisp XP Windows Menu Bar.

Entdecke dieMöglichkeiten (Wer hat das nochmals gesagt? )

Liebe Grüsse
Matze K.

[beachmeat]

Freut mich

Nur ist doch irgendwie das Problem, das das dynamische Auswerten von Argumenten problematisch bleibt.

Wenn man z.B. eine Methode eines anderen Objektes aufrufen möchte, und an diese ebenso diverse Argumente übergeben möchte - was dann?

Muss man also noch ne Klasse machen, die sowas ermöglicht

[beachmeat]

Ahoi, na da hab ich doch was schönes gefunden:

_global.Command = function ()
{
    if (arguments[0] == undefined)
    {
        return;
    }
    var a = arguments[0];
    if (arguments.length > 1)
    {
        this.obj = a;
        this.method = a[arguments[1]];
        this.args = arguments.slice (2);
    }
    else if (a instanceof Function)
    {
        this.method = a;
    }
    else if (typeof a == "string")
    {
        var idxOfParensL = a.indexOf ("(");
        var pathToMethod = a.slice (0, idxOfParensL);
        this.obj = eval (pathToMethod.slice (0, pathToMethod.lastIndexOf (".")));
        this.method = eval (pathToMethod);
        this.args = a.slice (idxOfParensL + 1, a.lastIndexOf (")")).split (",");
    }
};
Command.prototype.execute = function ()
{
    var cmd = this;
    Command.callback = function (params)
    {
        Command.data = arguments;
        cmd.callbackCommand.execute ();
        cmd.onComplete ();
    };
    return this.method.apply (this.obj, this.args);
}; 

Dies stammt von http://flashAPI.yestoall.com und bietet die gewünschte Funktionalität. Saugt euch am besten die API und schaut euch Command an um den zu verstehen

Was sich nun am Code der Klasse verändert, ist die Methode "action":

o.action = function()
{
    argArr = [];
    for(var i=0; i<this.passedArgs.length; i++)
    {
        if(this.passedArgs[i].evaluate != null)
        {
            if(this.passedArgs[i].evaluate == "static")
                argArr[i] = eval(this.passedArgs[i].arg)
            else 
                argArr[i] = this.passedArgs[i].arg.execute()
        }
        else argArr[i] = this.passedArgs[i].arg
    }
    this.scope[this.func].apply(this.scope,argArr);
} 

und der Aufruf des Shortcuts, das Argument "passedArgs":

obj.passedArgs  = [{arg:new Command(myObject.sub, "evaluateFunc", 10,7),evaluate:"command"},{arg:"hallo", evaluate:null},{arg:"mc._x", evaluate:"static"}] 

evaluate "command" bedeutet also, das der Command ausgeführt wird
evaluate "static" wertet nur eine Eigenschaft aus
null ist n konstanter Wert

[bokel]

Eigentlich führt das ein bißchen zuweit, oder ?
Die Verantwortung des ShortCut-Objekts sollte
dann enden, wenn es das Ereignis gemeldet hat.
Sonst landest du in letzter Konsequenz da, dass alle
Programmlogik vom ShortCut-Objekt realisiert wird

Hier ist mal eine Version, die das Key-Objekt so erweitert,
dass sich Listener für die Shortcuts eintragen können.
Der Name der aufgerufenenen Methode setzt sich dabei
aus den KeyCodes der Tastenkombination zusammen:

function KeyShortCutsExtensionClass() {
    //trace("KeyShortCutsExtensionClass");
    this.keysDown = {};
    this.combis = {};
    Key.addListener(this);
}
//
o = KeyShortCutsExtensionClass.prototype;
//
o.addCombi = function() {
    //trace("KeyShortCutsExtensionClass.addCombi " + arguments);
    //wie merken uns die akt. Kombination
    this.combis[arguments.toString()] = 1;
};
//
o.removeCombi = function(arguments) {
    //trace("KeyShortCutsExtensionClass.removeCombi " + arguments);
    delete this.combis[arguments.toString()];
};
//
o.checkKeys = function() {
    //trace("KeyShortCutsExtensionClass.checkKeys");
    var result = [];
    for (var i = 0; i < 256; i++) {
        if (Key.isDown(i)) {
            result.push(i);
        }
    }
    //trace("KeyShortCutsExtensionClass.checkKeys " + result);
    if (this.combis[result.toString()]) {
        Key.broadcastMessage("onKeyCombi_" + result.join("_"));
    }
};
//
o.onKeyDown = o.checkKeys;
//
// Statische Methode um das Key-Objekt zu initialisieren
KeyShortCutsExtensionClass.initialize = function(){
    //trace("KeyShortCutsExtensionClass.initialize");
    Key.shortCuts = new this();
    Key.addCombi = function(){
        this.shortCuts.addCombi.apply(this.shortCuts, arguments);
    }
    Key.removeCombi = function(){
        this.shortCuts.removeCombi.apply(this.shortCuts, arguments);
    }
}
//
//-----------------------------------------------
// Test
//-----------------------------------------------
//Keyobjekt erweitern
KeyShortCutsExtensionClass.initialize();
// Shortcut hinzufügen Strg-A
Key.addCombi(17, 65);
// Shortcut hinzufügen Strg-B
Key.addCombi(17, 66);
//
//
// Die Handler, die bei ShortCut aufgerufen werden
fObj = {};
fObj.onKeyCombi_17_65 = function() {
    trace("fObj.onKeyCombi_17_65");
};
Key.addListener(fObj);
//
//Ein Handler kann auch auf mehrere Ereignisse 
//reagieren
fObj2 = {};
fObj2.onKeyCombi_17_65 = function() {
    trace("fObj2.onKeyCombi_17_65");
};
fObj2.onKeyCombi_17_66 = function() {
    trace("fObj2.onKeyCombi_17_66");
};
 
Key.addListener(fObj2);
// 
 

mfg r.

[beachmeat]

Jajaja da hasde wohl recht, wieder zuviel in ein
Modul gequetscht.

Die Broadcasterlösung gefällt mir gut, außer der 0-256 Schleife [aber interessante Lösung], zumal die bei mir mit "strg" nen Fehler produziert (STRG ergibt 17 UND 162)

Is wohl richtig, das ne eigene Funktion für jede TastenKombination die kompaktere Lösung ist, zumal die Logik des auswertens da wirklich nix zu suchen hat.

[bokel]

Dann ist doch bestimmt deine Tastatur kaputt

Eine Kombination deiner Tastenerkennung mit der
Liste der Tasten hier hinein wäre dann wohl ganz
gut.

Dann werden auch nur die Tasten abgefraggt ,
die wirklich erwartet werden und nicht noch hunderte
andere.

Machst du fertig ?

mfg r.

[beachmeat]

Mit meiner Tastatur is alles in Ordnung - frag mich auch was das soll - laut charCode is das diese Zeichen: ¢ -komisch- is auch nich die einzige Taste, Shift auch noch z.B

_root.onEnterFrame = function ()
{
    for (var i = 0; i < 256; i++)
    {
        if (Key.isDown (i))
            trace (i);
    }
}; 

HHowever, here we go:

function KeyShortCutsExtensionClass() {
        this.keysDown = {};
        this.combis = {};
        Key.addListener(this);
}
//
o = KeyShortCutsExtensionClass.prototype;
//
o.addCombi = function() {
        this.combis[arguments.sort().toString()] = 1;
};
//
o.removeCombi = function() {
        delete this.combis[arguments.sort().toString()];
};
 
 
o.onKeyDown = function(code)
{
    var k = Key.getCode()
    if (!this.keysDown[k])
    {
        this.keysDown[k] = true
        this.checkKeys()
    }
}
 
o.onKeyUp = function(code)
{
    var k = Key.getCode()
    if (this.keysDown[k])
    {
        delete this.keysDown[k]
        this.checkKeys()
    }
}
 
o.checkKeys = function()
{
    var tArr = []
    for(var i in this.keysDown)
    {
        tArr.push(i)
    }
    tArr.sort()
            if (this.combis[tArr.toString()]) 
            {
                Key.broadcastMessage("onKeyCombi_" + tArr.join("_"));
 
    }
}
 
 
 
 
 
//
// Statische Methode um das Key-Objekt zu initialisieren
KeyShortCutsExtensionClass.initialize = function(){
        //trace("KeyShortCutsExtensionClass.initialize");
        Key.shortCuts = new this();
        Key.addCombi = function(){
                this.shortCuts.addCombi.apply(this.shortCuts, arguments);
        }
        Key.removeCombi = function(){
                this.shortCuts.removeCombi.apply(this.shortCuts, arguments);
        }
}
//
//-----------------------------------------------
// Test
//-----------------------------------------------
//Keyobjekt erweitern
KeyShortCutsExtensionClass.initialize();
 
 
// Shortcut hinzufügen Strg-A
Key.addCombi(17, 65);
Key.addCombi(17, 83);
 
//
// Die Handler, die bei ShortCut aufgerufen werden
fObj = {};
fObj.onKeyCombi_17_65 = function() {
        trace("fObj.onKeyCombi_17_65");
};
fObj.onKeyCombi_17_83 = function() {
        trace("fObj.onKeyCombi_17_83");
};
 
 
Key.addListener(fObj); 

Strenggenommen ist das garnich ECMA konform, weil wir Objekt Props numerisch beginnen - woscht

[bokel]

Genau,
in diesem Fall, wo wir die Liste als
Dictionary benutzen, ist das m. E.
erlaubt.

Sieht gut aus, Daumen hoch.

mfg r.

[beachmeat]

na DEN Daumen muss ich zurückgeben

wie waäre es den, wenn man add keyCombi entfernen würde, und IMMER broadcastet welche keys grade gedrückt sind, dann würde man sich das sparen, und die Implementation würde sich auf die onKeyKombi reduzieren - der Broadcaster würde also blind broadcasten (was er ja eh tut) und nur die entsprechenden Listener würde ihre Kombis auffangen - der rest schiesst ins Nirvana - Performance dürfte das ja nix antun...

mach das mal grad...