GUI-Referenz

AutoIt bietet die Möglichkeit, einfache Graphische Benutzeroberflächen (Graphical User Interfaces, GUIs) zu erstellen, die aus Fenstern und Steuerelementen (controls) bestehen.

 

GUI-Konzepte

Eine GUI besteht aus einem oder mehreren Fenstern und jedes Fenster enthält ein oder mehrere Steuerelemente. GUIs sind "ereignisbasiert", d.h., sie reagieren auf Ereignisse - z.B. auf den Klick auf einen Button. Die meiste Zeit verbringt man damit, auf Ereignisse zu warten - anders als in normalen Skripten, in denen du selbst kontrollierst, was passiert und wann es passiert. Stelle es dir vor, wie wenn man an der Türe auf den Briefträger wartet - du sitzt da, bis ein Brief in den Briefkasten geworfen wird, holst ihn heraus und entscheidest dann, was du damit machen willst. Genau so funktioniert eine GUI prinzipiell - du wartest darauf, dass der Briefträger zu dir kommt.

Natürlich kannst du während die GUI läuft auch andere Aufgaben durchführen. Du könntest z.B. eine Fortschrittsanzeige in der GUI realisieren, die den Fortschritt komplexer Skriptaktionen darstellt.

 

GUI-Controls

Alle Computer-Nutzer sind mit Steuerelementen (controls) vertraut. Alles, was du anklickst oder mit dem du interagierst, ist eine Art von Steuerelement. Alle in AutoIt verfügbaren Steuerelemente (die meisten kennst du aus anderen Windowsprogrammen) sind hier aufgelistet:

  • Label
  • Ein einfacher Text.
  • Button
  • Eine einfache Schaltfläche.
  • Input
  • Ein einzeiliges Steuerelement, in das man Text eingeben kann (Textfeld).
  • Edit
  • Ein mehrzeiliges Texteingabefeld.
  • Checkbox
  • Ein Kontrollkästchen, das markiert sein kann oder nicht.
  • Radio
  • Eine Gruppe von Optionsfeldern - nur eines davon kann gleichzeitig aktiv sein.
  • Combo
  • Eine Liste mit einer ausklappbaren Auswahl.
  • List
  • Eine Liste.
  • Date
  • Ein Datumsauswahl-Element.
  • Pic
  • Ein Bild.
  • Icon
  • Ein Icon.
  • Progress
  • Ein Fortschrittsbalken.
  • Tab
  • Eine Gruppe von Controls, die auf Registerkarten platziert sind.
  • UpDown
  • Pfeiltasten, die zu Textfeldern hinzugefügt werden können, um den Wert bequem zu vergrößern oder verkleinern.
  • Avi
  • Zeigt einen Videoclip im AVI-Format an.
  • Menu
  • Ein Menü an der oberen Kante des Fensters (Hauptmenü).
  • ContextMenu
  • Ein Menü, das erscheint, wenn man innerhalb des Fensters die rechte Maustaste betätigt.
  • TreeView
  • Eine Strukturansicht, die der Baumdarstellung im Windows Explorer ähnelt.
  • Slider
  • Ein Schieberegler, der der Lautstärkeregelung von Windows ähnelt.
  • ListView
  • Ein Control, das Informationen in Spalten anzeigt.
  • ListViewItem
  • Ein Control, das ein Element in einem Listview-Control darstellt.
  • Dummy
  • Ein Dummy-Nutzer-Control.

     

    Hier ein Beispiel eines einzigen GUI-Fensters, das viele der verfügbaren Controls enthält. Du siehst, dass selbst komplexe und detaillierte GUIs möglich sind!

     

    Controls werden mit der GUICtrlCreate...-Funktionsgruppe erstellt. Wenn ein Control kreiert wird, wird eine Control ID zurück gegeben. Das wichtigste, was man über diese Control ID wissen muss:

  • Die Control ID ist eine positive Zahl (also eine Ganzzahl größer als 0)
  • Jede Control ID wird nur einmal vergeben, selbst wenn es mehrere Fenster gibt.
  • Die Control ID ist derselbe Wert, den das AutoIt Window Info Tool anzeigt.
  •  

    Basis-GUI-Funktionen

    Es folgenden die Funktionen, die du am häufigsten zur GUI-Erstellung benötigst. Es sind nur die einfachen Funktionen, es gibt noch viele weitere, die es erlauben, detaillierte GUIs zu erstellen.

    Funktion Erklärung
    GUICreate Erstellt ein Fenster.
    GUICtrlCreate... Erstellt verschiedene Controls in einem Fenster.
    GUISetState Zeigt oder versteckt ein Fenster.
    GUIGetMsg Findet heraus, ob ein GUI-Ereignis aufgetreten ist (nur im MessageLoop-Modus).
    GUICtrlRead Liest Daten aus einem Control.
    GUICtrlSetData Setzt/verändert Daten in einem Control.
    GUICtrlSet... Verändert verschiedene Eigenschaften von Controls (Farbe, Stil, etc.).

     

    Bevor du überhaupt GUI-Skripte schreiben kannst, musst du die Datei GUIConstants.au3 am Beginn deines Skriptes einbinden.  Diese Dateien beinhalten alle Variablen und Konstanten, die zum Schreiben von GUIs benötigt werden.

     

    Erstellen wir zunächst ein Fenster mit dem Titel "Hallo Welt" und setzen die Größe auf 200 mal 100 Pixel. Wenn ein neues Fenster erstellt wird, ist es zunächst versteckt - wir müssen es also noch anzeigen ("show"):

    #include <GUIConstants.au3>

    GUICreate("Hallo Welt", 200, 100)
    GUISetState(@SW_SHOW)
    Sleep(2000)

     

    Wenn du das obige Skript ausführst, siehst du, wie sich das Fenster öffnet und nach 2 Sekunden wieder schließt - nicht gerade interessant... Fügen wir ein bisschen Text und einen Ok-Button hinzu! Der Text wird an der Position 30, 10 und der Button bei 70, 50 erscheinen. Der Button wird 60 Pixel breit sein:

    #include <GUIConstants.au3>

    GUICreate("Hallo Welt", 200, 100)
    GUICtrlCreateLabel("Hallo Welt! Wie geht es dir?", 30, 10)
    GUICtrlCreateButton("OK", 70, 50, 60)
    GUISetState(@SW_SHOW)
    Sleep(2000)

     

    Das sieht doch schon ganz gut aus. Aber wie lassen wir die GUI auf unseren Klick auf den Button reagieren? Nun, das ist  der Punkt, an dem wir eine Entscheidung darüber treffen müssen, wie wir Ereignisse verarbeiten wollen - entweder via eines MessageLoops oder via OnEvent-Funktionen.

     

    GUI-Ereignis-Modi

    Wie oben erwähnt gibt es zwei grundlegende GUI-Modi: den MessageLoopModus und den OnEvent Modus. Die Modi sind einfach zwei verschiedene Wege, um auf GUI-Ereignisse zu reagieren. Welchen Modus du wählst, hängt von deiner persönlichen Vorliebe ab, und bis zu einem gewissen Grad davon, welchen GUI-Typ du erstellen willst. Mit beiden Modi kannst du jede gewünschte GUI erstellen, aber manchmal ist ein Modus passender für eine Aufgabe als der andere.

    Der übliche (default) Modus ist der MessageLoop Modus.  Um auf den OnEvent Modus umzuschalten verwende Opt("GUIOnEventMode", 1).

     

     

    Message-loop Modus (default)

    Im Message-loop Modus wird dein Skript die meiste Zeit in einer engen Schleife verbringen. Diese Schleife wird einfach ständig die GUI mit der GUIGetMsg Funktion abfragen. Wenn ein Ereignis aufgetreten ist, zeigt der Rückgabewert der GUIGetMsg Funktion die Details an (ein Button wurde angeklickt, die GUI wurde geschlossen, etc.).

    In diesem Modus wirst du nur von Ereignissen erfahren solange du aktiv immer wieder die GUIGetMsg Funktion aufrufst; deshalb musst du sicherstellen, dass du sie viele Male pro Sekunde aufrufst, sonst wird deine GUI nicht reagieren.

    Dieser Modus ist am besten für GUIs geeignet, wenn die GUI der "König" ist und du nur auf Benutzeraktionen wartest.

    Auf dieser Seite findest du eine detailliertere Erklärung des MessageLoop Modus.

     

    OnEvent Modus

    Anstatt die GUI ständig abzufragen, um herauszufinden ob etwas passiert ist, lässt du im OnEvent Modus die GUI zeitweise dein Skript anhalten und eine vordefinierte Funktion aufrufen, um das Ereignis zu behandeln. Wenn zum Beispiel ein Nutzer auf Button1 klickt, hält die GUI dein Hauptskript an und ruft eine vorher von dir definierte Funktion auf, die für Button1 zuständig ist. Wenn diese Funktion abgearbeitet ist, wird das Hauptskript fortgesetzt. Dieser Modus ist ähnlich wie die Visual Basic Formular-Methode.

    Dieser Modus ist am besten für GUIs geeignet, wenn die GUI weniger wichtig ist und dein Skript zusätzlich zur GUI andere Aufgaben zu erfüllen hat.

    Auf dieser Seite findest du eine detailliertere Erklärung des OnEvent Modus.