1. Dashboard
  2. Mitglieder
    1. Letzte Aktivitäten
    2. Benutzer online
    3. Team
    4. Mitgliedersuche
  3. Forenregeln
  4. Forum
    1. Unerledigte Themen
  • Anmelden
  • Registrieren
  • Suche
Alles
  • Alles
  • Artikel
  • Seiten
  • Forum
  • Erweiterte Suche
  1. AutoIt.de - Das deutschsprachige Forum.
  2. Mitglieder
  3. AspirinJunkie

Beiträge von AspirinJunkie

  • Eintrag in einem ListView verschieben

    • AspirinJunkie
    • 13. August 2007 um 17:53

    Hab mir mal Gedanken gemacht wie man mit der Funktion die Items auch einfach per Drag & Drop verschieben kann.

    Musste dafür aber die Funktion geringfügig ändern damit es korrekt funktioniert.
    Falls es mal jemand brauchen sollte:


    Spoiler anzeigen
    [autoit]

    #include <GUIConstants.au3>
    #include <GuiListView.au3>

    [/autoit] [autoit][/autoit] [autoit]

    Opt("GUIOnEventMode", 1)

    [/autoit] [autoit][/autoit] [autoit]

    $GUI = GUICreate("Test-GUI", 500, 300, -1, -1, -1, $WS_EX_ACCEPTFILES)
    GUISetOnEvent($GUI_EVENT_CLOSE, "raus")
    GUISetOnEvent($GUI_EVENT_PRIMARYDOWN, "_MoveListViewItem")
    $ListView = GUICtrlCreateListView("Eintrag", 10, 10, 480, 280)
    _GUICtrlListViewSetColumnWidth($ListView, 0, 475)

    [/autoit] [autoit][/autoit] [autoit]

    For $i = 1 To 10
    $Item = GUICtrlCreateListViewItem("Eintrag " & $i, $ListView)
    Next

    [/autoit] [autoit][/autoit] [autoit]

    GUISetState(@SW_SHOW)

    [/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

    While 1
    Sleep(100)
    WEnd

    [/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

    Func raus()
    Exit
    EndFunc ;==>raus

    [/autoit] [autoit][/autoit] [autoit]

    ;Function by [email='AspirinJunkie@german-nlite.de'][/email] (benötigt globale Variable $ListView)
    Func _MoveListViewItem()
    Local $von, $bis, $down = GUIGetCursorInfo($GUI)

    [/autoit] [autoit][/autoit] [autoit]

    If $down[4] = $ListView Then
    $von = _GUICtrlListViewGetHotItem($ListView)

    [/autoit] [autoit][/autoit] [autoit]

    While $down[2]
    $down = GUIGetCursorInfo($GUI)
    Sleep(50)
    WEnd

    [/autoit] [autoit][/autoit] [autoit]

    If $down[4] = $ListView Then
    $bis = _GUICtrlListViewGetHotItem($ListView)

    [/autoit] [autoit][/autoit] [autoit]

    If Not ($von = $bis) Then
    _MoveLVItem($von, $bis - $von, $ListView)
    _GUICtrlListViewSetItemSelState($ListView, $bis, 1, 1)
    EndIf
    EndIf
    EndIf
    EndFunc ;==>_MoveListViewItem

    [/autoit] [autoit][/autoit] [autoit]

    ;----------------------------------------------------------------------------------------------------------------------
    ; Funktion _MoveLVItem($ItemIndex, $StepWidth, $hLV)
    ;
    ; Beschreibung verschiebt per Index angegebenen Eintrag eines ListViewCtrl um eine Anzahl Positionen
    ;
    ; Parameter $ItemIndex: Index der Zeile
    ; $StepWidth: Anzahl Zeilen um die der Eintrag verschoben wird (negative Zahl - aufwärts)
    ; $hLV: ListView ID
    ;
    ; Erfordernisse #include <GuiListView.au3>
    ;
    ; Autor BugFix ([email='bugfix@autoit.de'][/email])
    ;----------------------------------------------------------------------------------------------------------------------
    #include <GuiListView.au3>
    Func _MoveLVItem($ItemIndex, $StepWidth, $hLV)
    If ($ItemIndex + $StepWidth) < 0 Or _
    ($ItemIndex + $StepWidth) > _GUICtrlListViewGetItemCount($hLV) - 1 Then
    SetError(1)
    Return 0
    EndIf
    Local $txt2skip = _GUICtrlListViewGetItemText($hLV, $ItemIndex)

    [/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

    If $StepWidth > 0 Then
    _GUICtrlListViewInsertItem($hLV, $ItemIndex + $StepWidth + 1, $txt2skip)
    _GUICtrlListViewDeleteItem($hLV, $ItemIndex)
    Else
    _GUICtrlListViewInsertItem($hLV, $ItemIndex + $StepWidth, $txt2skip)
    _GUICtrlListViewDeleteItem($hLV, $ItemIndex + 1)
    EndIf

    [/autoit] [autoit][/autoit] [autoit]

    Return -1
    EndFunc ;==>_MoveLVItem

    [/autoit]
  • if -- elseif -- ifend

    • AspirinJunkie
    • 9. August 2007 um 18:26

    Folgendes Skriptchen sollte das selbe bewirken:

    [autoit]

    For $i = 68 To 77
    If DriveGetSerial(Chr($i) & ':\') = '1263730919' Then MsgBox(0, "Meldung", 'Laufwerk ' & Chr($i) & ':\ ist Dein Stick')
    Next

    [/autoit]

    Dabei werden einfach in einer Schleife alle Buchstaben von "D" ( ASCII-Code 68 !) bis "M" durchlaufen ( ASCII-Code 77 )

  • Flexible Parameterübergabe (Konsole)

    • AspirinJunkie
    • 9. August 2007 um 12:46

    Ne is ja klar - reguläre Ausdrücke lernt man nicht mal so in paar Stunden.
    Das schöne daran aber ist das es nicht auf AutoIt begrenzt ist sondern fast überall vorkommt.
    Deswegen gibt es viel Material dazu.

    Empfehle dir z.B. >>dieses Tutorial<<.


    Wenn ich das schon poste sollte ich es auch erklären.
    Also gut fangen wir an:

    Die erste Zeile sollte klar sein.
    Danach splitten wir unseren Parameterstring mittels RegExp.
    Hier die Erklärung zu meinem Pattern:

    Code
    '-(\w) ([\w\.]+)'

    Ein Bindestrich gefolgt von einem Buchstaben ( \w ).
    Der Buchstabe wird in Klammern gesetzt weil er damit einzeln ausgegeben wird.
    Dann kommt ein Leerzeichen und eine Reihe von Buchstaben oder (das in eckigen Klammern bedeutet "oder") Punkten ( \. ) mit einer Mindestlänge von einem Zeichen ( + ).
    Das zweite wird ebenfalls wieder in Klammern gesetzt damit es dann gesondert ausgeben wird.

    Was wir nun erhalten ist das Array $r welches folgende Elemente enthält:

    Spoiler anzeigen
    Code
    [0] S
    [1] Suchstring
    [2] m
    [3] BlaBla

    Man erkennt also das die Bindestrich-Parameter einen geraden Index haben und ihr zugehöriger Spezifizierungsparameter einen Index weiter folgt (also ein ungerader Index).

    Mit "If IsArray($r) Then" prüfen wir lediglich ob überhaupt was gefunden wurde da es sonst einen Fehler geben würde.
    Nun können wir unser 2-Dim Array $P erstellen welches später die Parameter in gewünschter Form aufnehmen soll.
    Da wissen wir ja nun das es insgesamt halb so viele Elemente geben soll wie Elemente in $r vorhanden sind (da dort für einen Eintrag ja je 2 Index belegt sind).
    Deswegen deklarieren wir unser Array $P so:

    Dim $P[UBound($r)/2][2]

    Das heißt das die Länge der ersten Dimension halb so viele Elemente umfassen soll wie Elemente in $r vorhanden sind ( UBound($r) ).
    Die [2] für die 2. Dimension ist denke ich klar.

    Nun wird unser Array $r komplett durchlaufen:

    For $i = 0 To UBound($r)-1

    $i enthält dann immer den jeweiligen Index des Elementes von $r bei welchem wir uns aktuell befinden.

    Nun zur gemeinsten Zeile ;):

    [autoit]

    $P[$i/2][Mod($i,2)] = $r[$i]

    [/autoit]

    Dies bedeutet:

    Schreibe unser Ausgabearray $P.
    Da wir ja sagten das es nur halb so viele Elemente wie in $r gibt können wir die erste Dimension mit [$i / 2] festlegen - warum?:

    $i gibt den aktuellen Index von $r an.
    Wäre $i gerade z.B. [2] dann wären wir beim Bindestrich-Parameter des eigentlich 2. Gesamtparameters.
    Also wollen wir es in unser Ausgabearray $P an die 2. Position in der ersten Dimension haben.
    Teilen wir [2] durch 2 erhalten wir "1" - also die 2. Stelle in unserem neuen Array (da "0" ja die erste Stelle ist).
    Gehen wir nun weiter und erhöhen $i um 1 auf nun [3] haben wir nun den Spezialisierungsparameter des 2. Gesamtparameters.
    Teilen wir hier nun $i durch 2 erhalten wir "1.5".
    Da als Index aber nur Ganzzahlen zugelassen sind wird intern einfach die ".5" abgeschnitten - wir haben also nun wieder "1" - also wieder die 2. Stelle in unserem Ausgabearray.

    Nun müssen wir das Element in die richtige Position in der 2. Dimension bringen.

    Dafür ist Mod($i,2) zuständig.
    Diese Funktion prüft $i auf die Teilbarkeit durch 2.
    Ist es ohne Rest teilbar - also eine gerade Zahl (und damit unsere Bindestrich-Parameter) erhalten wir als Ausgabewert der Funktion eine "0" - und damit unseren gewünschten Index der 2. Position.
    Ist die Zahl ungerade erhalten wir "1" - und damit den anderen Index.

    Ich hoffe mal das hat dich bisschen weiter gebracht erstmal.

  • Flexible Parameterübergabe (Konsole)

    • AspirinJunkie
    • 9. August 2007 um 12:01

    Sorry mir war grad langweilig.
    So sollte es auch gehen:


    Spoiler anzeigen
    [autoit]

    #include <array.au3>

    [/autoit] [autoit][/autoit] [autoit]

    $CMDLineRaw = 'fileop datei.txt -S Suchstring -m BlaBla'
    $r = StringRegExp($CMDLineRaw, '-(\w) ([\w\.]+)', 3)
    If IsArray($r) Then
    Dim $P[UBound($r)/2][2]
    For $i = 0 To UBound($r)-1
    $P[$i/2][Mod($i,2)] = $r[$i]
    Next
    _ArrayDisplay($P, 'Parameterliste')
    EndIf

    [/autoit]
  • Root Verzeichnis ermitteln

    • AspirinJunkie
    • 6. August 2007 um 16:15

    Der Laufwerksbuchstabe steht doch schon mit in der Variablen @ScriptDir drin - nämlich die ersten 3 Zeichen.
    Um den Laufwerksbuchstaben auszulesen brauchst du also nur die ersten 3 Zeichen von ScriptDir zu nehmen - fertig.

    So:

    [autoit]

    $SkriptLaufwerk = StringLeft(@ScriptDir, 3)

    [/autoit]
  • Root Verzeichnis ermitteln

    • AspirinJunkie
    • 6. August 2007 um 14:36

    [Blockierte Grafik: http://img125.echo.cx/img125/8038/01welcome7jb.gif]

    Das Makro "@Scriptdir" enthält das Verzeichnis in welchem sich das Skript befindet.

  • werte richtig an function übergeben

    • AspirinJunkie
    • 3. August 2007 um 16:08

    Das sieht für mich aus als würde es dieses Objekt auf deinem System nicht geben.
    Welche .Net FrameWork Version hast du denn installiert?

  • werte richtig an function übergeben

    • AspirinJunkie
    • 3. August 2007 um 15:53

    Hast du das Skript so wie es ist, ohne irgendeine Veränderung getestet und ausgeführt?

    So wie es ist funktioniert es bei mir problemlos.

    Probiere es nochmal mit diesem und sag mal Bescheid ob eine Meldung kommt das die Hash nicht erstellt werden konnte:

    Spoiler anzeigen
    [autoit]

    Opt("TrayOnEventMode",1)
    Opt("TrayMenuMode",1)

    global $hash = ObjCreate("System.Collections.Hashtable")

    [/autoit] [autoit][/autoit] [autoit]

    If Not IsObj($hash) Then
    MsgBox(0,"", "Konnte Hash nicht erstellen!")
    Exit
    EndIf

    [/autoit] [autoit][/autoit] [autoit]

    $soundmenue = TrayCreateMenu ("Konten")
    $Exit = TrayCreateItem ("Exit")
    TrayItemSetOnEvent(-1, "raus")

    [/autoit] [autoit][/autoit] [autoit]

    $Pfad = 'D:\Neu' ;hier deinen Ordner eintragen in welchem sich die mp3´s befinden

    TraySetState()

    $search = FileFindFirstFile($Pfad & "\*.mp3")
    If $search = -1 Then Exit

    [/autoit] [autoit][/autoit] [autoit]

    While 1
    $file = FileFindNextFile($search)
    If @error Then ExitLoop
    $item = TrayCreateItem($file,$soundmenue)
    TrayItemSetOnEvent(-1, "_play")

    $hash.add($item, $Pfad & "\" & $file) ;weißt einem Tray-Item die entsprechende Datei zu

    WEnd

    While 1
    sleep (100)
    wend

    [/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

    func _play()
    SoundPlay($hash(@TRAY_ID)) ;spielt die Datei ab welche zum entsprechenden Tray-Item gehört
    endfunc

    [/autoit] [autoit][/autoit] [autoit]

    Func raus()
    Exit
    EndFunc

    [/autoit]

    Ach und bitte keine Fullquotes - in der Regel weiß der Angesprochene was er geschrieben hat... ;)


    Edit: kleinen Bug gefixt

  • werte richtig an function übergeben

    • AspirinJunkie
    • 3. August 2007 um 14:53

    Doch kannst du - die Funktion darf aber keinen Parameter enthalten - musst das also entsprechend anders bauen.

    Hier mal als Beispiel wie ich vermute wie du dies gemeint hast (außerdem ein schönes Beispiel für die Verwendung einer Hash-Tabelle):

    Spoiler anzeigen
    [autoit]

    Opt("TrayOnEventMode",1)
    Opt("TrayMenuMode",1)

    [/autoit] [autoit][/autoit] [autoit]

    global $hash = ObjCreate("System.Collections.Hashtable")
    $soundmenue = TrayCreateMenu ("Konten")

    [/autoit] [autoit][/autoit] [autoit]

    $Pfad = 'D:\Neu' ;hier deinen Ordner eintragen in welchem sich die mp3´s befinden

    [/autoit] [autoit][/autoit] [autoit]

    TraySetState()

    [/autoit] [autoit][/autoit] [autoit]

    $search = FileFindFirstFile($Pfad & "\*.mp3")
    While 1
    $file = FileFindNextFile($search)
    If @error Then ExitLoop
    $item = TrayCreateItem($file,$soundmenue)
    TrayItemSetOnEvent(-1, "_play")

    $hash.add($item, $Pfad & "\" & $file) ;weißt einem Tray-Item die entsprechende Datei zu

    WEnd

    func _play()
    SoundPlay($hash(@TRAY_ID)) ;spielt die Datei ab welche zum entsprechenden Tray-Item gehört
    endfunc

    While 1
    sleep (100)
    wend

    [/autoit]
  • werte richtig an function übergeben

    • AspirinJunkie
    • 3. August 2007 um 14:28

    Die Funktion welche in TraySetItemOnEvent als Parameter angegeben wird muss selbst parameterlos sein.

  • StringRegExp

    • AspirinJunkie
    • 3. August 2007 um 00:13

    Aso - du meintest das andersrum - na dann dürfte das mit dem "normalen" StringRegExp besser sein:

    [autoit]

    #include <array.au3>

    $array = StringRegExp('Fahbswgh523wsefgo', '\d+',1 )
    _ArrayDisplay ($array)

    [/autoit]
  • StringRegExp

    • AspirinJunkie
    • 2. August 2007 um 23:51

    Nimm lieber StringRegExpReplace().

    [autoit]

    $test = StringRegExpReplace('Fahbswgh523wsefgo', '\d','' )
    msgbox(0, "", $test)

    [/autoit]
  • Alternativen zum Array

    • AspirinJunkie
    • 1. August 2007 um 20:56

    Eine Liste hat im Vergleich zu einem Array vor allem dann Vorteile wenn es darum geht öfters Elemente der Datenstruktur hinzuzufügen oder zu entfernen.
    In diesem Fall ist der Geschwindigkeitszuwachs enorm.
    Diesen Vorteil haben alle hier vorgestellten Strukturen gegenüber einen Array.

    Wenn die Datenmenge stabil bleibt ist ein Array die von der Performance her gesehen die wohl etwas bessere Wahl.

    Desweiteren bietet beispielsweise die Hashtabelle Vorteile wenn du einem Index einen Wert zuweist.
    Würde man etwas ähnliches über Arrays bewerkstelligen wollen würde man auf ein 2D-Array ausweichen welches einmal den Namen des Index enthält und als 2. den entsprechenden Wert.
    Hat man nun den Indexnamen und möchte den passenden Wert dazu müsste man erst das gesamte Array danach durchsuchen - hier hat die Hash-Tabelle wiederrum Vorteile - vor allem in der Geschwindigkeit und in der Komplexizität das dafür nötigen Codes.

    Ein Stack oder eine Queue können vor allem den Code deutlich vereinfachen.
    Prinzipiell braucht man bei einem Stack ja fast nur Push und Pop - viel einfacher kann man es gar nicht haben... ;)

    Zusammengefasst:

    Diese Möglichkeiten können(!!!) die Performance drastisch erhöhen, die Speicherauslastung effizienter gestalten und den Code verkürzen und vereinfachen.
    Dies ist aber abhängig von der entsprechenden Verwendung.
    Alle Methoden haben ihre Vor und Nachteile.

  • Alternativen zum Array

    • AspirinJunkie
    • 1. August 2007 um 18:18

    In AutoIt werden fast außschließlich Arrays (Felder) als Datenstruktur eingesetzt.
    Arrays sind aber nicht immer die beste Wahl.
    Im Prinzip stellt ein Array einen Speicherbereich dar in dem alle Werte hintereinander stehen.
    Das führt dazu das man die einzelnen Werte mit einem Index ansprechen kann.
    Allerdings hat dies auch einen entscheidenden Nachteil:
    Arrays sind absolut undynamisch.
    Wenn man ein Element hinzufügen möchte, muss das komplette Array dann in einen Speicherbereich kopiert werden der dessen Größe aufnehmen kann.
    Ebenso verhält es sich beim Löschen eines Elementes - mindestens die nachfolgenden Elemente müssten alle um eine Position verrückt werden.
    Das führt dazu das bei solchen Aktionen Arrays enorm uneffizient sind und man nach Alternativen Ausschau halten sollte welche dieses Problem nicht haben und wenn es geht noch andere Vorteile bieten.

    Die wichtigsten dieser Alternativen möchte ich hier nun vorstellen und zeigen wie man sie in AutoIt verwenden kann:

    Die Liste

    Bei einer Liste stehen die einzelnen Elemente nicht hintereinander im Speicher sondern alle verteilt.
    Damit die Liste zu einer Einheit wird enthalten die einzelnen Elemente zusätzlich zu ihrem Wert noch eine Information darüber wo sich das nächste Element im Speicher befindet (Pointer).
    Das führt dazu das man ohne viel Aufwand Elemente löschen oder hinzufügen kann da einfach nur ein Wert erstellt oder gelöscht werden muss und ein entsprechender Verweis beim vorherigen Element geändert werden muss.
    Eine Liste ist in diesen Fällen enorm schneller als ein Array.

    Prinzipiell sind Listen aber nicht indiziert wie z.B. Arrays - möchte man auf die Elemente zugreifen müsste man theoretisch immer die Liste vom Anfang durchlaufen.
    In der Praxis gibt es aber ein paar Tricks wie man dies umgehen kann.

    Verwendung in AutoIt:

    System.Collections.ArrayList
    [autoit]

    #include <Array.au3>

    [/autoit] [autoit][/autoit] [autoit]

    ;----------------------------------------------------------------------
    ;------------------------Array-List------------------------------------
    ;----------------------------------------------------------------------
    ; http://msdn.microsoft.com/de-de/library/….arraylist.aspx

    [/autoit] [autoit][/autoit] [autoit]

    ;////Array-List Erstellen///////////
    $AList = ObjCreate("System.Collections.ArrayList")

    [/autoit] [autoit][/autoit] [autoit]

    ;////Einträge hinzufügen///////////
    $AList.add ("Test1")
    $AList.add ("Test6")
    $AList.add ("Test4")
    $AList.add ("Test2")
    $AList.add ("Test3")
    $AList.add ("Test5")

    [/autoit] [autoit][/autoit] [autoit]

    ;////ArrayList sortieren///////////
    $AList.sort

    [/autoit] [autoit][/autoit] [autoit]

    ;////alle Elemente durchgehen///////////
    For $element In $AList
    ConsoleWrite($element & @CRLF)
    Next

    [/autoit] [autoit][/autoit] [autoit]

    ;////Element löschen///////////
    $AList.Remove("Test2") ;Löscht das angegebene Element (soweit vorhanden)

    [/autoit] [autoit][/autoit] [autoit]

    ;////löscht Eintrag an gegebenen Index///////////
    $AList.RemoveAt (3) ;Entfernt das Element an der 4. Position

    [/autoit] [autoit][/autoit] [autoit]

    ;////gibt Eintrag an gegebenen Index zurück///////////
    $Item = $AList.Item(2) ;gibt den Index des Items an der 3. Stelle zurück

    [/autoit] [autoit][/autoit] [autoit]

    ;////Eintrag an bestimmter Stelle einfügen///////////////
    $AList.Insert (2, "Eingefügt!") ;fügt Wert an 3. Position ein.

    [/autoit] [autoit][/autoit] [autoit]

    ;////Anzahl der Elemente bestimmen///////////
    $Count = $AList.Count

    [/autoit] [autoit][/autoit] [autoit]

    ;////Überprüft ob ein Element vorhanden ist///////////
    If $AList.Contains ("Test200") Then MsgBox(0, "", "Element vorhanden!") ;hier im Beispiel ist Element nicht vorhanden

    [/autoit] [autoit][/autoit] [autoit]

    ;////Listen zusammenfügen///////////
    $queue = ObjCreate("System.Collections.Queue")
    $queue.Enqueue ("QueueWert1")
    $queue.Enqueue ("QueueWert2")
    $queue.Enqueue ("QueueWert3")
    $queue.Enqueue ("QueueWert4")
    $AList.AddRange ($queue)

    [/autoit] [autoit][/autoit] [autoit]

    ;////Umwandlung in Array///////////
    $Array = $AList.ToArray ;kopiert Werte in ein Array (Liste ist immer noch vorhanden)
    _ArrayDisplay($Array, "Test")

    [/autoit] [autoit][/autoit] [autoit]

    ;////Löscht Liste///////////
    $AList.Clear

    [/autoit] [autoit][/autoit] [autoit]

    ;////Index eines Elementes bestimmen///////////
    $Index = _ArrayList_GetIndexOf($AList, "Test1")

    [/autoit] [autoit][/autoit] [autoit]

    Func _ArrayList_GetIndexOf(ByRef $ArrayList, $element)
    Local $counter = 0

    [/autoit] [autoit][/autoit] [autoit]

    If Not IsObj($ArrayList) Then
    SetError(1)
    Return 0
    EndIf

    [/autoit] [autoit][/autoit] [autoit]

    For $elem In $AList
    If $elem = $element Then Return $counter
    $counter += 1
    Next

    [/autoit] [autoit][/autoit] [autoit]

    SetError(2)
    Return 0
    EndFunc

    [/autoit]

    Natürlich können die Elemente dieser Strukturen auch Arrays sein - das hat dann einen ähnlichen Effekt wie ein 2-Dim-Array.
    Hier mal ein Beispiel dazu:

    Spoiler anzeigen
    [autoit]

    $TestList = ObjCreate("System.Collections.ArrayList")

    [/autoit] [autoit][/autoit] [autoit]

    For $i = 0 To 25
    Dim $TestArray[4] = [$i, 2 * $i, 3 * $i, 4 * $i]
    $TestList.add ($TestArray)
    Next

    [/autoit] [autoit][/autoit] [autoit]

    For $element In $TestList
    ConsoleWrite(StringFormat("%2d",$element[0]) & ' ' & StringFormat("%2d",$element[1]) & ' ' & StringFormat("%2d",$element[2]) & ' ' & StringFormat("%2d",$element[3]) & @CRLF)
    Next

    [/autoit]

    Die Warteschlange (Queue)

    Eine Queue ist im Prinzip eine Art Liste.
    Allerdings hat man hierbei immer nur Zugriff auf ein Element - nämlich das was als erstes hinzugefügt wurde.
    Eine Queue arbeitet nämlich im FirstIn-FirstOut-Prinzip.
    Als praktisches Beispiel gilt der Namensgeber.
    Alle Elemente werden hinzugefügt.
    Dann arbeitet man der Reihe nach die Elemente ab in der Reihenfolge wie sie hinzugefügt wurden.
    Holt man das erste Element heraus steht nun das vormals 2. als nächstes bereit usw.
    Dennoch kann man munter weiter Elemente hinzufügen.


    Verwendung in AutoIt:

    System.Collections.Queue
    [autoit]

    #include <Array.au3>

    [/autoit] [autoit][/autoit] [autoit]

    ;----------------------------------------------------------------------
    ;------------------------Queue-----------------------------------------
    ;----------------------------------------------------------------------
    ; http://msdn.microsoft.com/de-de/library/…ions.queue.aspx

    [/autoit] [autoit][/autoit] [autoit]

    ;////Queue Erstellen///////////
    $queue = ObjCreate("System.Collections.Queue")

    [/autoit] [autoit][/autoit] [autoit]

    ;////Eintrag an das Ende der Warteschlange hinzufügen///////////
    $queue.Enqueue ("Erster Eintrag")
    $queue.Enqueue ("Zweiter Eintrag")
    $queue.Enqueue ("Dritter Eintrag")
    $queue.Enqueue ("Vierter Eintrag")

    [/autoit] [autoit][/autoit] [autoit]

    ;////Überprüft ob ein Element vorhanden ist///////////
    If $queue.Contains ("Fünfter Eintrag") Then MsgBox(0, "", "is drin!")

    [/autoit] [autoit][/autoit] [autoit]

    ;////Erstes Element anzeigen (ohne löschen)///////////
    ConsoleWrite( $queue.Peek & @CRLF )

    [/autoit] [autoit][/autoit] [autoit]

    ;////Anzahl der Elemente bestimmen///////////
    $Count = $queue.Count

    [/autoit] [autoit][/autoit] [autoit]

    ;////Erstes Element herausholen///////////
    $firstelement = $queue.Dequeue

    [/autoit] [autoit][/autoit] [autoit]

    ;////Umwandlung in Array///////////
    $Array = $queue.ToArray
    _ArrayDisplay($Array, "Test")

    [/autoit]

    Der Stapelspeicher (Stack)

    Ein Stack ist im Prinzip eine invertierte Queue denn er arbeitet im LastIn-FirstOut-Prinzip.
    Im Gegensatz zur Queue kann man hier also nur das letzte Element was man hinzugefügt hatte herausholen.

    Verwendung in AutoIt:

    System.Collections.Stack
    [autoit]

    #include <Array.au3>

    [/autoit] [autoit][/autoit] [autoit]

    ;----------------------------------------------------------------------
    ;------------------------Stack-----------------------------------------
    ;----------------------------------------------------------------------
    ; http://msdn.microsoft.com/de-de/library/…ions.stack.aspx

    [/autoit] [autoit][/autoit] [autoit]

    ;////Stack Erstellen///////////
    $Stack = ObjCreate("System.Collections.Stack")

    [/autoit] [autoit][/autoit] [autoit]

    ;////Eintrag an den Stack anfügen///////////
    $Stack.Push ("Erster Eintrag")
    $Stack.Push ("Zweiter Eintrag")
    $Stack.Push ("Dritter Eintrag")
    $Stack.Push ("Vierter Eintrag")

    [/autoit] [autoit][/autoit] [autoit]

    ;////Oberstes Element herausholen///////////
    $firstelement = $Stack.Pop

    [/autoit] [autoit][/autoit] [autoit]

    ;////Erstes Element anzeigen (ohne löschen)///////////
    ConsoleWrite( $Stack.Peek & @CRLF)

    [/autoit] [autoit][/autoit] [autoit]

    ;////Anzahl der Elemente bestimmen///////////
    $Count = $Stack.Count

    [/autoit] [autoit][/autoit] [autoit]

    ;////Überprüft ob ein Element vorhanden ist///////////
    If $Stack.Contains ("Fünfter Eintrag") Then MsgBox(0, "", "Element vorhanden")

    [/autoit] [autoit][/autoit] [autoit]

    ;////Umwandlung in Array///////////
    $Array = $Stack.ToArray
    _ArrayDisplay($Array, "Test")

    [/autoit]

    Die Hash-Tabelle

    Eine HashTable ist eine indizierte Datenstruktur.
    Das heißt einem Index wird ein Wert zugeordnet.
    Wenn man den Namen des Index kennt kann man damit sehr schnell auf seinen entsprechenden Wert zugreifen.

    Eine bessere Vorstellung davon sollte man anhand der Beispielimplementierung in AutoIt erhalten:

    System.Collections.Hashtable
    [autoit]

    ;----------------------------------------------------------------------
    ;------------------------Hash-Table------------------------------------
    ;----------------------------------------------------------------------
    ; http://msdn.microsoft.com/de-de/library/….hashtable.aspx

    [/autoit] [autoit][/autoit] [autoit]

    ;////Hash-Table Erstellen///////////
    $hash = ObjCreate("System.Collections.Hashtable")

    [/autoit] [autoit][/autoit] [autoit]

    ;////Einträge hinzufügen///////////
    $hash.add ("Berlin", 3395189)
    $hash.add ("Hamburg", 1743627)
    $hash.add ("München", 1259677)
    $hash.add ("Köln", 983347)
    $hash.add ("Dresden", 504795)
    ;Beispiel hier: Einwohnerzahl wird der jeweiligen Stadt zugeordnet.

    [/autoit] [autoit][/autoit] [autoit]

    ;////Anzahl der Elemente bestimmen///////////
    $Count = $hash.Count

    [/autoit] [autoit][/autoit] [autoit]

    ;////Überprüft ob ein Element vorhanden ist///////////
    If $hash.Contains ("Bonn") Then MsgBox(0, "", "Bonn ist eingetragen") ;Bonn ist im Bsp. nicht enthalten

    [/autoit] [autoit][/autoit] [autoit]

    ;////Löscht ein Element aus der Hash-Table///////////
    $hash.remove ("München")

    [/autoit] [autoit][/autoit] [autoit]

    ;////Elemente aufrufen///////////
    ConsoleWrite("Einwohner(Berlin): " & $hash("Berlin") & @CRLF)
    ConsoleWrite("Einwohner(Dresden): " & $hash("Dresden") & @CRLF)

    [/autoit] [autoit][/autoit] [autoit]

    ;////Leert die Hash-Table///////////
    $hash.Clear

    [/autoit]


    Das Dictionary

    Das Dictionary ist wie die Hash-Tabelle ein assoziatives Array:

    Scripting.Dictionary
    [autoit]

    ;//// Dictionary Erstellen ///////////
    ; http://msdn.microsoft.com/en-us/library/…4(v=vs.84).aspx
    $oDict = ObjCreate("Scripting.Dictionary")

    [/autoit] [autoit][/autoit] [autoit]

    ;//// Einträge hinzufügen ///////////
    $oDict.add ("Berlin", 3395189)
    $oDict.add ("Hamburg", 1743627)
    ; Alternativ (keine Fehler falls schon existiert und auch Werte damit veränderbar):
    $oDict("München") = 1259677
    $oDict("Köln") = 983347
    $oDict("Dresden") = 529781

    [/autoit] [autoit][/autoit] [autoit]

    ;//// Anzahl der Elemente bestimmen ///////////
    MsgBox(0,"Anzahl Elemente in Dictionary", $oDict.Count)

    [/autoit] [autoit][/autoit] [autoit]

    ;//// Überprüft ob ein Element vorhanden ist ///////////
    If $oDict.Exists ("Bonn") Then MsgBox(0, "", "Bonn ist eingetragen") ;Bonn ist im Bsp. nicht enthalten

    [/autoit] [autoit][/autoit] [autoit]

    ;//// Löscht ein Element aus dem Dictionary ///////////
    $oDict.remove ("München")

    [/autoit] [autoit][/autoit] [autoit]

    ;//// Elemente aufrufen ///////////
    ConsoleWrite("Einwohner(Berlin): " & $oDict("Berlin") & @CRLF)
    ConsoleWrite("Einwohner(Dresden): " & $oDict("Dresden") & @CRLF & @CRLF)

    [/autoit] [autoit][/autoit] [autoit]

    ;//// alle Schlüssel durchgehen ///////////
    For $k in $oDict.Keys
    ConsoleWrite("Einwohner(" & $k & "): " & $oDict($k) & @CRLF)
    Next
    ; Alle Werte statt Schlüssel erreicht man mit $oDict.Items

    [/autoit] [autoit][/autoit] [autoit]

    ;//// Leert das Dictionary ///////////
    $oDict.RemoveAll

    [/autoit]


    Dictionary und Hash-Tabelle unterscheiden sich lediglich hinsichtlich der internen Implementierung.
    Das führt dazu dass ein Dictionary bei einer kleinen Anzahl an Elementen performanter beim Hinzufügen von Elementen ist als die Hash-Tabelle während es sich bei einer großen Anzahl an Elementen andersherum verhält.
    Dies dauert bei einem Dictionary immer länger je mehr Elemente in der Struktur stehen. Bei der Hash-Table bleibt der Zeitaufwand dafür immer der selbe.
    Bei mir liegt diese Grenze grob bei etwa 400.000 Elementen.
    Will man selbst ermitteln ab wann sich eines von beiden eher lohnt kann man z.B. folgendes Skript verwenden ($N anpasen):

    Speedvergleich Dictionary-Hashtable
    [autoit]

    Global $oDic = ObjCreate("Scripting.Dictionary")
    Global $oHash = ObjCreate("System.Collections.Hashtable")

    [/autoit] [autoit][/autoit] [autoit]

    Global Const $N = 1e6

    [/autoit] [autoit][/autoit] [autoit]

    $iT = TimerInit()
    For $i = 1 To $N
    $oDic.add($i, "Teststring")
    Next
    $iT = TimerDiff($iT)
    ConsoleWrite(StringFormat("Dictionary:\t%7.1f ms\n", $it))

    [/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

    $iT = TimerInit()
    For $i = 1 To $N
    $oHash.add($i, "Teststring")
    Next
    $iT = TimerDiff($iT)
    ConsoleWrite(StringFormat("Hash-Table:\t%7.1f ms\n", $it))

    [/autoit]

    Die Sorted-List
    Die Sorted-List ist wie die Hash-Table und das Dictionary ein assoziatives Array (Schlüssel-Wert-Paare).
    Im Unterschied zu diesen stehen die Elemente immer in einer, nach dem Schlüssel, sortierten Reihenfolge.

    System.Collections.SortedList
    [autoit]


    ;----------------------------------------------------------------------
    ;------------------------Sorted-List------------------------------------
    ;----------------------------------------------------------------------
    ; http://msdn.microsoft.com/de-de/library/…sortedlist.aspx

    [/autoit] [autoit][/autoit] [autoit]

    ;//// Sorted-List erstellen ///////////
    $SList = ObjCreate("System.Collections.SortedList")

    [/autoit] [autoit][/autoit] [autoit]

    ;//// Elemente hinzufügen ///////////
    $SList.add("Berlin", 3395189)
    $SList.add("Hamburg", 1743627)
    ; Alternativ (keine Fehler falls schon existiert und auch Werte damit veränderbar):
    $SList("München") = 1259677
    $SList("Köln") = 983347
    $SList("Dresden") = 529781
    $SList("Stuttgart") = 606.588
    $SList("Dortmund") = 580.444

    [/autoit] [autoit][/autoit] [autoit]

    ;//// Test ob Schlüssel oder Wert existiert ///////////
    If $SList.ContainsKey("Bonn") Then MsgBox(0, "", "Bonn ist eingetragen")
    If $SList.ContainsValue(100000) Then MsgBox(0, "", "Eine Stadt mit 100.000 Einwohnern ist eingetragen")

    [/autoit] [autoit][/autoit] [autoit]

    ;//// Elemente anhand Schlüssel oder Index löschen ///////////
    $SList.Remove("München") ; Eintrag "München" wird gelöscht
    $SList.RemoveAt(3) ; der 2. Eintrag (Hamburg) wird gelöscht

    [/autoit] [autoit][/autoit] [autoit]

    ;//// Elemente anhand Schlüssel oder Index suchen ///////////
    ConsoleWrite("Index von Köln: " & $SList.IndexOfKey("Köln") & @CRLF)
    ConsoleWrite("Index der Stadt mit 529.781 Einwohnern: " & $SList.IndexOfValue(529781) & @CRLF & @CRLF)

    [/autoit] [autoit][/autoit] [autoit]

    ;//// Alle Elemente durchlaufen ///////////
    For $i = 0 To $SList.Count - 1
    ConsoleWrite($SList.GetKey($i) & @TAB & $SList.Getbyindex($i) & @CRLF)
    Next

    [/autoit] [autoit][/autoit] [autoit]

    ;//// Sorted-List leeren ///////////
    $SList.Clear

    [/autoit]

    Nun ich hoffe die hier vorgestellten Alternativen regen den ein oder anderen dazu an wenigstens mal zu schauen was damit geht und gegebenfalls das nächste mal einfach mal auf ein Array zu verzichten... ;)
    Zu einer effektiven Programmgestaltung können diese Datenstrukturen eine Menge beitragen.

    Und um die Sache zum Ausprobieren noch ein bisschen schmackhafter zu machen habe ich hier noch eine Funktion erstellt welche ein 1-Dim-Array direkt in eine Liste, Queue oder Stack umwandelt:

    Spoiler anzeigen
    [autoit]

    #include <Array.au3>

    [/autoit] [autoit][/autoit] [autoit]

    Global $Arr[5] = [1, 2, 3, 4, 5]

    [/autoit] [autoit][/autoit] [autoit]

    $Queue = _ArrayToList($Arr, "Queue", 0, UBound($Arr) - 1, 1)

    [/autoit] [autoit][/autoit] [autoit]

    If Not @error Then
    $Temp = $Queue.ToArray
    _ArrayDisplay($Temp)
    EndIf

    [/autoit] [autoit][/autoit] [autoit]

    ;=================================================================================================
    ;
    ; Function Name: _ArrayToList()
    ; Description: Konvertiert ein 1-dimensionales Array in eine Liste, Queue oder Stack
    ;
    ; Parameter(s): $Array - Das zu konvertierende Array
    ; [Typ] - gewünschter Datenstrukturtyp:
    ; "List" = ArrayList (Default)
    ; "Queue" = Warteschlange
    ; "Stack" = Stapelspeicher
    ; [$von] - Start array index (Default = 0)
    ; [$bis] - End array index (Default = Ubound - 1)
    ; [DeleteArray] - löscht das umzuwandelnde Array nach Abarbeitung (Default = 0)
    ;
    ; Requirement(s): None.
    ; Return Value(s): bei Erfolg - Die gewünschte Datenstruktur
    ; Bei Fehler - 0
    ; @Error=1 - kein korrektes Array als Parameter angegeben
    ; @Error=2 - Bereichsfehler eines angegebenen Index
    ; @Error=3 - Falsche Angabe für den $Typ-Parameter
    ;
    ; Author(s): [email='AspirinJunkie@german-nlite.de'][/email]
    ;
    ; Note(s): Durch Vertauschen des $von mit dem $bis Parameter kann die
    ; Reihenfolge der Elemente vertauscht werden.
    ;
    ;=================================================================================================

    [/autoit] [autoit][/autoit] [autoit]

    Func _ArrayToList(ByRef $Array, $Type = "List", $von = 0, $bis = Default, $DeleteArray = 0)
    Local $i, $Liste, $Step = 1

    [/autoit] [autoit][/autoit] [autoit]

    If Not IsArray($Array) Then
    SetError(1)
    Return 0
    EndIf

    [/autoit] [autoit][/autoit] [autoit]

    If $bis = Default Then $bis = UBound($Array) - 1

    [/autoit] [autoit][/autoit] [autoit]

    If $bis > UBound($Array) - 1 Or $von > UBound($Array) - 1 Or 0 > $von Or 0 > $bis Then
    SetError(2)
    Return 0
    EndIf

    [/autoit] [autoit][/autoit] [autoit]

    If $von > $bis Then $Step = -1

    [/autoit] [autoit][/autoit] [autoit]

    Switch $Type

    [/autoit] [autoit][/autoit] [autoit]

    Case "List"
    $Liste = ObjCreate("System.Collections.ArrayList")
    For $i = $von To $bis Step $Step
    $Liste.Add ($Array[$i])
    Next

    [/autoit] [autoit][/autoit] [autoit]

    Case "Queue"
    $Liste = ObjCreate("System.Collections.Queue")
    For $i = $von To $bis Step $Step
    $Liste.Enqueue ($Array[$i])
    Next

    [/autoit] [autoit][/autoit] [autoit]

    Case "Stack"
    $Liste = ObjCreate("System.Collections.Stack")
    For $i = $von To $bis Step $Step
    $Liste.Push ($Array[$i])
    Next

    [/autoit] [autoit][/autoit] [autoit]

    Case Else
    SetError(3)
    Return 0

    [/autoit] [autoit][/autoit] [autoit]

    EndSwitch

    [/autoit] [autoit][/autoit] [autoit]

    If $DeleteArray Then $Array = 0

    [/autoit] [autoit][/autoit] [autoit]

    Return $Liste
    EndFunc ;==>_ArrayToList
    ;=================================================================================================

    [/autoit]

    P.S.: Hoffe mal BugFix liest das hier nicht - ich will nicht wissen was los ist wenn er sieht das ich öffentlich das Array diffamiere.... [Blockierte Grafik: http://forum.team-ingame.de/images/smilies/sofa.gif]

  • dll call version 3.1 --> 3.2.4.x FEHLER

    • AspirinJunkie
    • 30. Juli 2007 um 00:41

    Schreib mal bei dem Rückgabewert-Typ mal nur "int" statt "int:cdecl".

    Der Grund ist das die cdecl-Funktionalität erst seit Version 3.2.0 existiert - die Einstellung für diese Aufrufkonvention wurde also in früheren Versionen von AutoIt komplett ignoriert und es wurde, trotz deines Parameters, in der alten Version stdcall statt cdecl verwendet.

  • Navigieren in Baumstruktur

    • AspirinJunkie
    • 27. Juli 2007 um 18:06

    Gut - dann teste nochmal deine Rückgabewerte in dem du die Wingethandle-Zeile folgendermaßen abänderst:

    [autoit]

    $winhandle = WinGetHandle("[CLASS:ThunderRT6FormDC; INSTANCE:2]")

    [/autoit]

    Ansonsten würde ich in diesem Fall eher dazu raten auch den Fenstertitel als Vergleichskriterium mit einzubeziehen und außerdem als 2. Parameter noch zusätzlich einen Teil vom Fenstertext - denn nur der Klassenname reicht hier ja, wie wir sehen, nicht aus da es mehrere Fenster dieser Klasse gibt.

  • Navigieren in Baumstruktur

    • AspirinJunkie
    • 27. Juli 2007 um 17:51

    Hm - deine Parameter in der Zeile sind lt. Window-Info-Tool in Ordnung.
    Du kannst nochmal so geschrieben probieren - ist im Prinzip aber auch nur das selbe:

    [autoit]

    $treehandle = ControlGetHandle($winhandle, '', "[CLASS:TreeView20WndClass; INSTANCE:1]")

    [/autoit]

    Kann es sein das es zu dem Zeitpunkt mehrere Fenster gibt welche dieser Klasse entsprechen?

    Überprüfe das mal gegebenenfalls z.b. so:

    [autoit]

    Opt("WinTitleMatchMode", 4)

    [/autoit][autoit][/autoit][autoit]

    $WinList = WinList("[CLASS:ThunderRT6FormDC]")
    MsgBox(0,"", "Anzahl an Windows mit angegebener Klasse:" & @CRLF & @CRLF & $WinList[0][0])

    [/autoit]

    Könnte ja vielleicht sein das wir uns im falschen Fenster befinden... ;)

  • Navigieren in Baumstruktur

    • AspirinJunkie
    • 27. Juli 2007 um 17:29

    Was sagt denn Window-Info über das TreeView-Control (Classname, Instance etc.)

    Überprüfe auch mal ob die Control-ID des TreeView bei jedem Neustart des Programm immer gleich ist - dann könntest du auch einfach diese nehmen - dann aber ohne Anführungszeichen)

  • Navigieren in Baumstruktur

    • AspirinJunkie
    • 27. Juli 2007 um 17:05
    Zitat

    Original von mactoni
    wo kommt bei Xenobiologist Bsp. hier "SysTreeView321" her??

    Das ist der ClassName + die Instance - alle beide mit dem AutoIt-Window-Info-Tool ausgelesen.
    Der Classname ist "SystreeView32" die Instance ist "1" - beides zusammen ergibt die ClassNameNN.

    Man könnte das vielleicht mal testen wenn man den Namen des zu automatisierenden Programms hätte.

  • Navigieren in Baumstruktur

    • AspirinJunkie
    • 25. Juli 2007 um 15:56

    Ich glaube wegen dieses Beispieles übernehme ich jetzt mal... ;)

    Aaalso.
    Standardmäßig bietet AutoIt keine direkte Möglichkeit mit TreeViews umzugehen.
    Für diesen Zweck hat Paul Campbell (ist das so richtig?) eine "Erweiterung" für AutoIt geschrieben welche Windows-API-Funktionen nutzt.
    Also quasi die Befehle die Windows selbst verwendet um mit TreeViews umzugehen.
    Diese müsstest du dir erstmal >>hier<< herunterladen und installieren.

    Damit stehen uns nun weitere Funktionen zur Verfügung welche wir für unser TreeView nutzen wollen.

    Windows benötigt um mit TreeViews umzugehen nicht die Control-ID sondern ein Handle.
    Dies ist eine Kennung für z.B. Controls welche beim Erstellen immer neu vergeben werden.
    Diese dienen Windows dazu alle vorhandenen Controls zu unterscheiden.
    Diese bekommt man mit AutoIt aber relativ leicht heraus - nämlich über Controlgethandle() - ebenso mit Window-Handles - auch wenn es zugegeben hier nicht unbedingt notwendig ist).

    Jedenfalls haben wir dann ein Handle zu unseren Tree-View.
    Wir wollen aber einen einzelnen Eintrag daraus ansprechen.
    Die Einträge in unserem Tree-View sind ebenfalls eindeutig zugeordnet - die werden einfach von 0 aufwärts durchnummeriert.

    Um jetzt also einen Eintrag aus dem Tree-View anzusprechen brauchen wir lediglich das Control-Handle des Tree-View-Controls und seinen Index (hier im Skript als $NodeHandle bezeichnet).

    Hier in diesem Beispiel ist es so das wir ein Item von dem wir lediglich den Text kennen markieren wollen.
    Dazu müssen wir erst einmal seinen Index herausbekommen.

    Nach einem kurzen Blick in die Hilfe der AU3Lib erfahren wir das es dafür eine Funktion namens "_TreeView_FindNode" gibt.
    Diese benötigt als Parameter das Control-Handle (haben wir dort schon ausgelesen) und den Text nach dem gesucht werden soll.
    Was wir als Rückgabewert bekommen ist der Index des Eintrages.
    Damit können wir die Funktion "_TreeView_Select" füttern welche uns den Eintrag markieren soll - diese benötigt als Parameter das Control-Handle und den den Index des Eintrages - fertig.

    Ich hoffe das macht das ganze erst einmal ein bisschen verständlicher.

Spenden

Jeder Euro hilft uns, Euch zu helfen.

Download

AutoIt Tutorial
AutoIt Buch
Onlinehilfe
AutoIt Entwickler
  1. Datenschutzerklärung
  2. Impressum
  3. Shoutbox-Archiv
Community-Software: WoltLab Suite™