Beiträge von Professor Bernd
-
-
Hi Tweaky, eine Kleinigkeit, damit dir nicht langweilig wird.

Funktion AscW
Fehler im Beispiel:
Local $iCode = AscW("A")
MsgBox($MB_SYSTEMMODAL, "Unicode Code fürß: U+" & Hex($iCode, 6))
richtiger wäre:
Local $iCode = AscW("ß")
MsgBox($MB_SYSTEMMODAL, "", "Unicode Code für ß: U+" & Hex($iCode, 6))
-
-
-
Mit dem Dict habe ich bisher kaum gearbeitet. Vor allem nicht im ROT Kontext.... Kannst Du in beiden Scripten (also server und client) KeyValues hinzufügen und löschen, bzw. sortieren usw.?
Tja, da sehe ich nun, wie wenig ich weiß. Ich dachte, dass AutoItObject NICHT im ROT registriert wird und dann steht da im Header von "_AutoItObject_RegisterObject()" in der "AutoItObject.au3" dick und fett: "Registers the object to ROT". Aber ich weiß auch sehr wenig über ROT. "The Running Object Table (ROT) is a system global table where objects can register themselves. This makes the objects accessible in processes other than the process where the object was created."
So hat mich z.B. verwundert im Zusammenhang mit ROT über Server und Client zu lesen. In meinem Fall, wo ich ein COM ROT Dictionary Objekt benutze, braucht es keinen Server in dem Sinne. Ein Standard-Objekt wird erstellt ObjCreate("Scripting.Dictionary") und im ROT registriert $oRunningObjectTable.Register($iFlags, $pObject, $pMoniker, $iHandle). Danach ist das Dictionary in allen Scripts zur Verfügung, die das "Zauberwort" kennen, also der Moniker (Name) unter dem man das Dict im ROT registriert hat.
z.B. in AutoIt: $g_oDict_COM = ObjGet($sCOM_ROT_Name) ; Dictionary object
oder in VBScript: Set oCOM_Dict = GetObject(gc_sCOM_ROT_Name)
Das könnte man in weiteren Scripts mithilfe des Monikers abholen und benutzen, über Script-Sprachen-Grenzen hinweg. In meinem Fall zur IPC zwischen AutoIt und VBScript. Ein Server/Client oder Sender/Receiver Szenario ist dabei nicht nötig, da es sich um eine "zwei"-Wege-Kommunikation handelt. Eigentlich um eine mögliche Kommunikation zwischen allen Scripts, die auf das Dict zugreifen. Jeder kann lesen und schreiben und alles ist quasi "ByRef" (nicht wörtlich nehmen!). - Vielleicht verstehst du nun meine Faszination.

Was dein Thema betrifft, so dachte ich dabei an die Möglichkeit, die du beschrieben hast mit "tatsächlich habe ich gestern schon überlegt, ... die Objekte in eigene "Worker" auszulagern".
2. Kann ein AutoItObject-Object zur Laufzeit erweitert werden? Kann also ein zur Laufzeit erstelltes Modul seine Eigenschaften und Methoden dem bestehenden Au3-Objekt hinzufügen?
Ja! Man kann zu jedem Zeitpunkt eine Methode oder ein Attribut hinzufügen oder die Sichtbarkeit ändern (und wahrscheinlich auch löschen) - aber ich glaube man kann keine Objekte "kopieren".
Das hört sich doch schonmal gut an.
Das einzige Problem tritt hier auf, wenn das Objekt nicht im aktuellen Prozess erstellt wurde.
Heißt: Übergebe ich ein Objekt mittels ROT and ein anderes Script, kann ich dort nur noch Methoden aufrufen und Eigenschaften ändern; aber keine neuen erstellen.
Bist du sicher, dass es sich so verhält? Meiner Vorstellung nach sollte ein ROT Objekt für alle Scripts gleich verfügbar sein. Vielleicht wird das Objekt im aktuellen Script nicht geändert (im Sinne von aktualisieren des bestehenden Objekts) sondern neu erstellt? - Bedenke, dass ich hierbei nur rate, mein Wissen reicht dafür nicht aus!
Aber vielleicht liest ja jemand mit, der sich besser auskennt. 
PS: Zum Thema IPC hatte ich nun das hier gebaut:
Hi hi, hab gerade mal quer gelesen, da hast du ja selbst etwas entwickelt, was wahrscheinlich das weiter oben beschriebene Dictionary überflüssig macht.

Wieviel Aufwand wäre es denn, wenn du ein Minimal-Demo erstellst, mit einem Hauptscript das einen Button hat (und ein Edit*?), mit dem ein "Business Objekte" Script erzeugt werden kann? * Das Edit habe ich erwähnt, weil ich ja nicht weiß, wie die User das im echten Programm machen. - Dann sollten noch 1 - 2 Buttons drauf, die das machen bzw. nicht machen, worum es dir geht, also die Funktionen aus dem Unterscript aufrufen, ohne Prog-Neustart. Noch eine Datei hinzufügen, die den Code mit 1 - 2 Foo-Funktionen für das Unterscript enthält, den man im Edit einfügt, um das Unterscript per Button zu erstellen.
Vielleicht hilfst das, Ideen zu entwickeln. (Vielleicht hast du das aber schon längst gemacht in deinen vorherigen Postings und ich habe es nur nicht gesehen. Dann Schande über mich!)

-
Als Zusammenfassung sage ich mal das Offensichtliche: Es ist weniger ein Fehler in der Hilfe, als vielmehr ein Fehlen.
Bitnugger hatte vermutet, dass Bit 1 nicht reserviert ist. Das war zwar richtig, aber auch ein "falscher Fehler", denn seine Annahme bezog sich in Wirklichkeit nicht auf Bit 1, sondern auf die Werte von Bit 0, das entweder 0 oder 1 sein kann:
The Value ... bezieht sich also auf das flag 0
Durch diesen falschen Fehler hat sich dann herausgestellt, dass mittlerweile ein weiteres Flag hinzugekommen ist, das in Bit 1 ausgedrückt wird: LLKHF_LOWER_IL_INJECTED. Somit muss "1 to 3 - Reserved" tatsächlich "2 to 3 - Reserved" heißen, denn Bit 1 ist nun nicht mehr reserviert.

Ein wenig kompliziert, aber wenn unser Rechenweg nicht bewertet wird, zählt nur das Ergebnis.

-
Ich denke, dass die Reservierung und die Nicht-Dokumentation von Bit 1 aus der Zeit stammt, als die Struktur in AutoIt eingefügt wurde. Zu dieser Zeit hat Windows diese Bits tatsächlich nicht verwendet d.h. die derzeitige Dokumentation war richtig, wurde dann aber später nicht nachgezogen.
Für diese Annahme spricht das Flag LLKHF_LOWER_IL_INJECTED, das auf der MS Seite zu finden ist, aber in der AutoIt-Hilfe fehlt. - Dabei fällt mir auf, dass das auch ergänzt werden sollte.
LLKHF_EXTENDED (KF_EXTENDED >> 8 ) Test the extended-key flag. LLKHF_LOWER_IL_INJECTED 0x00000002 Test the event-injected (from a process running at lower integrity level) flag. LLKHF_INJECTED 0x00000010 Test the event-injected (from any process) flag. LLKHF_ALTDOWN (KF_ALTDOWN >> 8 ) Test the context code. LLKHF_UP (KF_UP >> 8 ) Test the transition-state flag. -
Hallo. Das Thema scheint recht komplex und ich kann im Moment keine Lösung anbieten, da es mein Wissen und meine Erfahrung übersteigt. Aber wenn ich darf hätte ich wahllose Gedanken zu bieten, die vielleicht Anregung für weitere Ideen sind.

Wie gesagt, mein Wissen über AutoItObject ist sehr bescheiden. Ich benutze z.B. AutoItServer.au3 aus dem Thread "Access AutoIt" von trancexx. Für mich sind eher COM ROT Objekte wichtig, z.B. hier von LarsJ, wobei interesannte Aspekte unter "Usage" beschrieben sind, z.B. gleich der erste Punkt "Passing array between AutoIt programs".
Ok, ich denke, es war für dich nicht leicht, eine so komplexe Sache auf eine einfach verständliche Erklärung zu reduzieren.
Wie dem auch sei, für mich kann es nicht einfach genug sein. Deshalb sei bitte nicht böse, wenn ich dumme Fragen stelle, ich versuche ja zu helfen. 
1. Die wichtigste Frage für mich: Müssen die "Module" (Scripte die die Klassen der Business Objekte enthalten) unbedingt in das Haupt-Modul/Script inkludiert werden? Wenn sie z.B. weiter als separate Module laufen können, braucht es keinen Neustart der Anwendung.
2. Kann ein AutoItObject-Object zur Laufzeit erweitert werden? Kann also ein zur Laufzeit erstelltes Modul seine Eigenschaften und Methoden dem bestehenden Au3-Objekt hinzufügen?
Verstanden habe ich, dass das dein Anliegen ist:
Kennt jemand einen einfacheren / besseren Weg um Funktionen zur Laufzeit zu generieren und dabei Daten/Funktionen Scriptübergreifend verfügbar zu machen?
In einem Script verwende ich ein Dictionary als COM ROT Objekt zur IPC zwischen AutoIt und VBScript. Ein Dict kann als KeyValues, glaube ich, so ziemlich alles aufnehmen, auch Arrays und Objekte. Vielleicht könnte man so deine Au3-Objekte in allen Modulen verfügbar machen. ...
... Oder nur die Daten. Z.B. könnte man die Module "lauschen lassen", ob ein bestimmter Key im Dict gesetzt ist, und falls True dann seine entsprechende Funktion ausführen (Parameter können ebenfalls im Dict übermittelt werden) und das Ergebnis (die Daten) im Dict speichern. Das Haupt-Modul holt sie aus dem Dict und verarbeitet sie. Nach meiner Erfahrung ist die Kommunikationsgeschwindigkeit zwischen den Modulen akzeptabel.
- Wie gesagt, ich denke nur mal laut, vielleicht ist es ja auch Unsinn.
Ich hätte noch weitere Gedanken, aber abhängig von deinen Antworten werden einige davon überflüssig.

-
Hier noch eine Schleifen-Variante:
Oh mann, wer braucht da noch Verschlüsselung!? So kryptisch, sooo kryptisch ... !






-
Y und z ist leider auch nicht überall gleich... Ich benutz US layout und da ist es vertauscht... Bei den beiden Zeichen merkt man auch oft, wenn sich programmierer keine Gedanken über layouts gemacht haben...
Oh ja! Was war das "damals" (zu XP-Zeiten?) ein Gräuel*, wenn man etwas beim Booten machen musste, sei es in DOS, oder der XP Reparaturkonsole, und es dann hieß, man solle "Y" für "Ja" drücken. Man drückte auf "Y" und nichts rührte sich ... das "Y" war beim Booten ja auf dem "Z". ... Das waren noch Zeiten.


* Gräuel: Boah, "damals" ist ebenso lange her, wie ich diese Wort schon nicht mehr gehört/benutzt habe. Gibts das überhaupt noch?

-
Nur die Bits 0, 4, 5 und 7 sind zur Auswertung relevant, die Bits 1-3 sind 'reserved'
Nur die Bits 2 - 3 sind reserviert (und Bit 6). Siehe mein vorheriges Posting.

-
Ahhh... ich denke ja, durch dein Einfügen von "Bit" wird es direkt viel verständlicher!
Für mich auch!

The Value ... bezieht sich also auf das flag 0
Das sehe ich auch so. Dadurch ergibt sich, dass nicht nur der Punkt "1 to 3 - Reserved" falsch ist, sondern dass auch die Info zum Bit 1 fehlt:
Laut MS-Docs
Bit 0 Specifies whether the key is an extended key, such as a function key or a key on the numeric keypad. The value is 1 if the key is an extended key; otherwise, it is 0. 1 Specifies whether the event was injected from a process running at lower integrity level. The value is 1 if that is the case; otherwise, it is 0. Note that bit 4 is also set whenever bit 1 is set. 2 - 3 Reserved. ... ... -
Sehe ich das richtig?
Nö.

KBDLLHOOKSTRUCT structure (winuser.h)
Ganz klar ist mir das mit der Zählweise nicht, aber offensichtlich beginnt die Zählung mit 0 für das niedrigstwertige Bit (LSB) auf der rechten Seite und läuft nach links. Somit ist das erste Bit rechts das Bit 0, das zweite von rechts ist das Bit 1, usw.
Wie dem auch sei, meiner Meinung nach hat Bitnugger recht und die Bits 2 - 3 sind reserviert (ebenso das Bit 6).
-
Was genau stört dich an der If-Then-Konstruktion?
Mich stört daran eigentlich gar nichts. Es ist nur ein (antrainiertes?) Gefühl, mehrere If-Abfragen mithilfe einer Schleife zu rationalisieren. Wie du siehst, habe ich diese Möglichkeit favorisiert. Ich habe auch schon gedacht, dass man damit seinen Code recht einfach erweitern kann, wenn man aus den einzeiligen If-Abfragen If-EndIf-Blöcke macht. Dann kann man gleich an Ort und Stelle einfügen, ob man nur Zahlen als Rückgabe haben will, oder wie es im Moment ist mit Text dahinter, oder gleich eine Aktion ausführen, usw.
Vorallem finde ich, genau wie du geschrieben hast, dass damit sehr klar ist, was passieren soll.
0xFFFF ist nur ein fiktives Beispiel bei dem das 4. Bit gesetzt ist. Brauchte halt nur irgendeinen knackigen Wert wo das BitAnd(...,
anschlägt.Verstanden!
Uff! Dadurch ist jetzt altes, verschüttetes Wissen entschüttet worden und ich kann mich wieder erinnern, warum man Flags als Zweierpotenzen anlegt. Denn 0xFFFF würde den Christbaum ganz schön zum leuchten bringen.

-
Hier noch 2 Schleifen-Variationen. Das Ergebnis könnte man mit "StringSplit()" auswerten. Ist zwar alles recht schön, aber einen praktischen Unterschied kann ich nicht erkennen. Sieht nach Geschmacksache aus.
AutoIt
Alles anzeigenLocal $iFlag = 6 ConsoleWrite('- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ' & @CRLF) ConsoleWrite(_ShiftState1($iFlag) & @CRLF) ConsoleWrite('- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ' & @CRLF) ConsoleWrite(_ShiftState2($iFlag) & @CRLF) ConsoleWrite('- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ' & @CRLF) Func _ShiftState1($_iFlag) Local $sRet = "" If $_iFlag = 0 Then Return '0' For $i = 0 To 5 ; ConsoleWrite(2^$i & @CRLF) If BitAND($_iFlag, 2^$i) Then $sRet &= 2^$i & "|" ; Pipe-Zeichen als Trenner. Next Return StringTrimRight($sRet, 1) ; Letztes Pipe-Zeichen entfernen. EndFunc ;==>_ShiftState Func _ShiftState2($_iFlag) Local $sRet = "" Local $iMask = 1 If $_iFlag = 0 Then Return '0' While $iMask < 33 ; ConsoleWrite(2^$i & @CRLF) If BitAND($_iFlag, $iMask) Then $sRet &= $iMask & "|" ; Pipe-Zeichen als Trenner. $iMask *= 2 WEnd Return StringTrimRight($sRet, 1) ; Letztes Pipe-Zeichen entfernen. EndFunc ;==>_ShiftStateEdit: If $_iFlag = 0 Then Return '0' eingefügt.
-
Soweit verstehe ich deine Erklärungen, bis auf die Stellen wo du 0xFFFF eingesetzt hast. Was hat es damit auf sich?
Ansonsten schonmal Danke für die Erläuterungen, dass da wohl praktisch kein Unterschied ist (abgesehen von der Effizienz). Somit favorisiere ich die Möglichkeit im ersten Beispiel, oder gibt es noch eine galanterere? (ohne RegExen)

-
Verständnisfrage.
Es gibt verschiedene Funktionen, die Zweier-Potenzen als Flags verwenden (heißt das so?), also 1, 2, 4, 8, 16, 32, ... Ein berühmter Vertreter dafür ist die MsgBox, die eine beachtliche Anzahl von Flags benutzt.
In diesem Thread möchte ich die Shift-States der Tastatur betrachten, die die Flags 1, 2, 4, 8, 16 und 32 benutzen. Auswerten kann man sie z.B. so:
Beispiel 1
Code
Alles anzeigenLocal $iFlag = 6 ConsoleWrite('- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ' & @CRLF) ConsoleWrite(_ShiftState($iFlag) & @CRLF) ConsoleWrite('- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ' & @CRLF) Func _ShiftState($_iFlag) Local $sRet If $_iFlag = 0 Then Return '0 [""]' If BitAND($_iFlag, 1) Then $sRet &= " 1, 'Either SHIFT key is pressed.' " If BitAND($_iFlag, 2) Then $sRet &= " 2, 'Either CTRL key is pressed.' " If BitAND($_iFlag, 4) Then $sRet &= " 4, 'Either ALT key is pressed.' " If BitAND($_iFlag, 8) Then $sRet &= " 8, 'The Hankaku key is pressed' " If BitAND($_iFlag, 16) Then $sRet &= " 16, 'Reserved (defined by the keyboard layout driver).' " If BitAND($_iFlag, 32) Then $sRet &= " 32, 'Reserved (defined by the keyboard layout driver).' " Return $sRet EndFunc ;==>_ShiftStateBeispiel 2
Code
Alles anzeigenLocal $iFlag = 6 ConsoleWrite('- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ' & @CRLF) ConsoleWrite(_ShiftState($iFlag) & @CRLF) ConsoleWrite('- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ' & @CRLF) Func _ShiftState($_iFlag) Local $sRet For $i = 0 To 6 Step 1 ; ConsoleWrite('BitAND(' & $_iFlag & ', ' & 2^$i & ') = ' & BitAND($_iFlag, 2^$i) & @CRLF) Switch True Case $_iFlag = 0 Return '0 [""]' Case BitAND($_iFlag, 2 ^ $i) = 1 $sRet &= " 1, 'Either SHIFT key is pressed.' " Case BitAND($_iFlag, 2 ^ $i) = 2 $sRet &= " 2, 'Either CTRL key is pressed.' " Case BitAND($_iFlag, 2 ^ $i) = 4 $sRet &= " 4, 'Either ALT key is pressed.' " Case BitAND($_iFlag, 2 ^ $i) = 8 $sRet &= " 8, 'The Hankaku key is pressed' " Case BitAND($_iFlag, 2 ^ $i) = 16 $sRet &= " 16, 'Reserved (defined by the keyboard layout driver).' " Case BitAND($_iFlag, 2 ^ $i) = 32 $sRet &= " 32, 'Reserved (defined by the keyboard layout driver).' " EndSwitch Next Return $sRet EndFunc ;==>_ShiftStateMeine Frage ist, was sind die praktischen Unterschiede? Für welchen Anwendungsfall ist die eine besser geeignet, als die andere? Oder ist am Ende alles gleich?

-
-
Auf die Gefahr hin, dass wir dann keine Freunde mehr sind... den habe ich in der Tat mal eben schnell aus dem Ärmel geschüttelt.
Guten Morgen Herr Bitnugger. Leider kann Professor Bernd nicht selbst antworten. Er ist ganz grün angelaufen, hat sich auf den Boden geworfen, schreit nur noch "Nein, nein, nein, ..." und reißt sich die letzen verbliebenen Haare aus.

-
Hier ein Schnipsel, der _GetLanguage() erweitern und den Code verkleinern kann:
C#include <WinAPILocale.au3> #include <WinAPISys.au3> Local $hexKeybLayout = _WinAPI_GetKeyboardLayout(WinGetHandle("[active]")) Local $sLayoutName = _WinAPI_GetLocaleInfo(BitAND($hexKeybLayout, 0xFFFF), $LOCALE_SENGLANGUAGE) ConsoleWrite(@CRLF & "---- KeyboardLayout: " & $hexKeybLayout &" LayoutName: " & $sLayoutName & @CRLF & @CRLF)Auch nützlich: WinAPIlangConstants.au3
Zu deinem Code. Hattest du den bei dir rumliegen, oder schnell mal aus dem Ärmel geschüttelt? (Bitte sag, dass du den NICHT mal eben schnell erstellt hast!)

Erstmal vielen Dank, da habe ich was zu knabbern! Das dauerd eine Weile, bis ich da durchblicke.
