Das erste Skript zeigt uns, wie man ein GUI erstellt, und anzeigt:
AutoIt-Quelltext
#include <GUIConstantsEx.au3> ;System-Ereignisse werden includet (Wird erst später beim Schließen benötigt)
$hGUI = GUICreate("Erstes GUI", 400, 400) ;GUI wird als $hGUI definiert, und hat eine Größe von 400x400
GUISetState(@SW_SHOW) ;GUI wird angezeigt
#include<GUIConstantsEx.au3>;System-Ereignisse werden includet (Wird erst später beim Schließen benötigt)
$hGUI=GUICreate("Erstes GUI",400,400);GUI wird als $hGUI definiert, und hat eine Größe von 400x400
Erklärung:
Zuerst einmal das #include. Für Leute die nicht wissen, was includes sind, werden sie jetzt noch mal erklärt. Includes, sind schon vorhandene Skripte, in einem Include-Ordner (Normalerweise: C:\Program Files\AutoIt3\Include), die in dein Skript mit eingebunden sind. In diesen Skripten, sind Funktionen, oder Variablen, o.ä. die man in seinem eigenen Skript dann benutzen kann. In den GUIConstantsEx.au3 sind Variablen, mit denen man das GUI schließen kann. Mehr zu den Variablen später.
Includes werden so geschrieben:
AutoIt-Quelltext
#include <DasZuIncludende.au3>
#include<DasZuIncludende.au3>
Kommen wir zu GUICreate. Mit GUICreate kann man ein GUI erstellen. Der erste Parameter ist der Titel der GUI. Er wird in Anführungszeichen geschrieben. Danach kommt die Breite und als letztes die Höhe. Weitere Parameter sind Positionen, Styles (s.Hilfe)!!
In diesem Skript wird die GUI als Variable $hGUI definiert. Das ist in diesem Skript nicht wirklich notwendig, aber später wird das definieren wichtig sein.
Als letztes wird die GUI angezeigt. Das geht mit der Funktion GUISetState. Wie man aus dem Namen lesen kann, wird der Zustand der GUI gesetzt. Das Makro @SW_SHOW bedeutet zeigen. Mehr zu den Makros in der Hilfe.
Wenn Sie vielleicht mal das Skript geöffnet haben, werden Sie feststellen, dass die GUI sich öffnet, aber sofort wieder schließt. Das liegt daran, dass das Skript die GUI erstellt, anzeigt, und dann beendet. Vielleicht kommt in ihrem Hinterkopf schon der Gedanke „ein Schleife“ auf. Wenn nicht, ist auch nicht so schlimm!
Um mit einem GUI Aktionen (z.B Beenden; angeklickte Buttons) zu registrieren gibt es zwei Möglichkeiten dies zu tun. Die eine Möglichkeit ist der OnEvent Modus, der andere der Message-Loop Modus.
Der Message-Loop Modus wird in einer Schleife verwendet. Die Schleife fragt die GUI permanent nach einem Ereignis mit der GUIGetMsg-Funktion.
Der Message-Loop Modus ist der Standart-Modus für AutoIt-GUIs. Es gibt zwei grundlegende Möglichkeiten den Message-Loop Modus in einer Schleife zu verwenden. Man könnte dazu eine Do-Until Schleife oder eine While Schleife benutzen. Gehen wir gleich zum Schließen der GUI. Das Schließen der GUI ist ein System-Ereignis, und System-Ereignisse sind negative Zahlen. Diese Zahlen sind in der au3-Datei GUIConstantsEx.au3 als Variablen definiert. Man könnte sie auch selber hinschreiben, aber sie sind so schwerer zu merken. Die Variable für Schließen ist $GUI_EVENT_CLOSE. Damit auch was passiert, wenn das GUI geschlossen werden soll, braucht man noch If, Switch oder Select. Hier wird If benutzt. Die Funktion GUIGetMsg stellt ja nichts an, sondern registriert nur den Befehl. Eine normale Message-Loop Schleife mit While sieht so aus:
AutoIt-Quelltext
; Bleibt im Leerlauf bis GUIGetMsg() = $GUI_EVENT_CLOSE ist, also das System-Ereignis Schließen registriert wird,
; und beendet das Script
While 1
$msg = GUIGetMsg()
Switch $msg
Case $GUI_EVENT_CLOSE
Exit
EndSwitch
WEnd
; Bleibt im Leerlauf bis GUIGetMsg() = $GUI_EVENT_CLOSE ist, also das System-Ereignis Schließen registriert wird,
;bleibt im Leerlauf, bis das System-Ereignis Schließen ($GUI_EVENT_CLOSE) registriert wird, und beendet das Script
Do
Sleep(10)
Until GUIGetMsg() = $GUI_EVENT_CLOSE
Exit
;bleibt im Leerlauf, bis das System-Ereignis Schließen ($GUI_EVENT_CLOSE) registriert wird, und beendet das Script
Wir werden die Do-Until Version nicht mehr benutzen, da das GUI so nur geschlossen werden kann. Man könnte keine anderen Ereignisse für den Message-Loop Modus einbauen.
Wenn wir die While Version in unser altes GUI-Script einbauen sieht es folgendermaßen aus:
AutoIt-Quelltext
#include <GUIConstantsEx.au3> ;System-Ereignisse werden includet
;GUI wird erstellt und angezeigt
$hGUI = GUICreate("Erstes GUI", 400, 400)
GUISetState(@SW_SHOW)
;Message-Loop wartet auf schließen, und beendet dann das Script
While 1
$msg = GUIGetMsg()
Switch $msg
Case $GUI_EVENT_CLOSE
Exit
EndSwitch
WEnd
#include<GUIConstantsEx.au3>;System-Ereignisse werden includet
Noch mal eine Erklärung. While 1 wird ständig wiederholt. Das heißt GUIGetMsg (Fragen nach Ereignissen) wird ständig wiederholt. Das Switch bedeutet: Falls das Ereignis $GUI_EVENT_CLOSE ist, also der Schließen-Button, dann soll das Script beendet werden (Exit).
Der OnEventMode ist anders als der Message-Loop Modus. Er hat sehr viel mit Funcs zutun.
Falls Sie jetzt nicht wissen, was eine Func ist, dann brauchen sie nicht weiterzulesen. Der Message-Loop Modus reicht für den Anfang. Lesen Sie lieber bei den Controls weiter. Ich setzte beim OnEventMode voraus, das Sie vorher Message-Loop Modus gelesen haben!
Der OnEventMode lässt eine Funktion bei einem Ereignis starten. Ein Ereignis erstellen, geht mit GUISetOnEvent. Dort gibt man an, was für ein Event das ist, und welche Func aufgerufen werden soll. Das heißt, sie schreiben z.B eine Func mit den Namen Exit, in der ein Script beendet wird. Wenn man auf den Schließen-Button klickt, dann unterbricht OnEvent alles, was gerade im Skript läuft, und ruft diese Funktion auf. OnEvent ist nicht der Standart Modus, deshalb muss er am Anfang des Scriptes mit Opt(’GUIOnEventMode’, 1) angeschaltet werden. Im nächsten Script ist der OnEventMode gleich mit dem alten GUI-Skript verbunden.
AutoIt-Quelltext
#include <GUIConstantsEx.au3> ; System-Ereignisse werden includet
Opt('GUIOnEventMode', 1) ; OnEventMode wird mit 1 eingeschaltet, mit 0 kann er ausgeschaltet werden
$hGUI = GUICreate("Erstes GUI", 400, 400) ; GUI wird wieder erstellt
GUISetOnEvent($GUI_EVENT_CLOSE, "_Exit") ; Beim Ereignis $GUI_EVENT_CLOSE (-3) also schließen, wird die Func _Exit() aufgerufen5
GUISetState(@SW_SHOW) ;GUI wird angezeigt
While 1
Sleep(10) ; Skript bleibt in einer Endlosschleife, also Leerlauf
WEnd
Func _OpenNewGUI()
GUIDelete($hGUI)
$hGUI2 = GUICreate("2te GUI", 400, 400)
GUISetOnEvent($GUI_EVENT_CLOSE, "_Exit")
GUISetState(@SW_SHOW)
While 1
Sleep(10)
WEnd
EndFunc
Func _Exit() ; _Exit() beendet das Script
If @GUI_WinHandle = $hGUI Then
_OpenNewGUI()
Else
Exit
EndIf
EndFunc
#include<GUIConstantsEx.au3>; System-Ereignisse werden includet
Opt('GUIOnEventMode',1); OnEventMode wird mit 1 eingeschaltet, mit 0 kann er ausgeschaltet werden
$hGUI=GUICreate("Erstes GUI",400,400); GUI wird wieder erstellt
GUISetOnEvent($GUI_EVENT_CLOSE,"_Exit"); Beim Ereignis $GUI_EVENT_CLOSE (-3) also schließen, wird die Func _Exit() aufgerufen5
In diesem Tutorial werden nur 2 von vielen Controls verwendet. Da jedoch die Control-Erstellung in vielen Fällen ähnlich bis gleich ist, werden wir nur 2 Controls behandeln. Den Button-Control und den Input-Control.
Fangen wir erst einmal an Controls zu erstellen. Controls sollten immer vor GUISetState(@SW_SHOW) erstellt werden. Eine Control-Erstellung geht mit GUICtrlCreate…. Nehmen wir uns erstmal die Control-Erstellung vor. Unser altes GUIScript sieht mit Controls folgendermaßen aus:
AutoIt-Quelltext
#include <GUIConstantsEx.au3> ;System-Ereignisse werden includet
;GUI und Controls werden erstellt und angezeigt
$hGUI = GUICreate("Erstes GUI", 400, 400)
$hInput = GUICtrlCreateInput("", 10, 10, 100, 20) ; Input wird erstellt, Control-ID ist $hInput
$hButton = GUICtrlCreateButton("Lesen", 10, 50, 70, 40) ; Button wird erstellt, Control-ID ist $hButton
GUISetState(@SW_SHOW)
;Message-Loop wartet auf schließen, und beendet dann das Script
While 1
$msg = GUIGetMsg()
Switch $msg
Case $GUI_EVENT_CLOSE
Exit
EndSwitch
WEnd
#include<GUIConstantsEx.au3>;System-Ereignisse werden includet
GUICtrlCreateInput erstellt einen Input-Control. Der Rückgabewert ist die Control-ID des Inputs, die als $hInput definiert wird. Man muss eine Control-ID nicht definieren, aber wenn man später eine Aktion mit dem Control machen will, dann braucht man die ID. Werden Sie später sehen!! Als erster Parameter sind zwei Anführungszeichen angegeben. Wieso?? Der erste Parameter ist das, was schon im Input drinnen steht, beim öffnen der GUI. Bei 2 Anführungszeichen steht nichts in der GUI. Die nächsten 2 Parameter sind Left-, und Toppositionen in der GUI. Und die letzten sind die Breite und Höhe.
Das Selbe ist beim Button-Control. Das erste ist die Beschriftung, danach wieder Left-, Toppositionen, Breite und Höhe. Das ist bei fast jedem Control so. Aber nun wollen wir die Controls mit Funktionen versehen. Das geht folgendermaßen:
AutoIt-Quelltext
#include <GUIConstantsEx.au3> ;System-Ereignisse werden includet
;GUI und Controls werden erstellt und angezeigt
$hGUI = GUICreate("Erstes GUI", 400, 400)
$hInput = GUICtrlCreateInput("", 10, 10, 100, 20) ; Input wird erstellt, Control-ID ist $hInput
$hButton = GUICtrlCreateButton("Lesen", 10, 50, 70, 40) ; Button wird erstellt, Control-ID ist $hButton
GUISetState(@SW_SHOW)
;Message-Loop wartet auf schließen, und beendet dann das Script
While 1
$msg = GUIGetMsg()
Switch $msg
Case $GUI_EVENT_CLOSE
Exit
Case $hButton ; Wenn der Message-Loop Modus einen Klick auf den Button registriert,
$read = GUICtrlRead($hInput) ;dann wird der Input ausgelesen,
MsgBox(0, "Gelesen", "In der Input-Box stand: " & $read) ;und ausgegeben.
EndSwitch
WEnd
#include<GUIConstantsEx.au3>;System-Ereignisse werden includet
Dafür braucht man die Control-ID eines Controls. GUICtrlRead ist eine sehr wichtige Funktion. Sie kann Controls auslesen. Das auslesen ist bei den Controls verschieden. Bei einer Input-Box liest GUICtrlRead die Buchstaben heraus. Diese werden dann als Variable $read definiert und mit einer MsgBox ausgegeben.
Dieses Kapitel schließt voraus, dass das Kapitel 3.1) gelesen wurde!!
Beim OnEventMode, wird wieder ein Event für den Control erstellt. GUIEvents erstellt man mit GUISetOnEvent. Control-Events werden aber mit GUICtrlSetOnEvent erstellt!!! Beim OnEventMode sieht das ganze folgendermaßen aus:
AutoIt-Quelltext
#include <GUIConstantsEx.au3> ; System-Ereignisse werden includet
Opt('GUIOnEventMode', 1) ; OnEventMode wird mit 1 eingeschaltet, mit 0 kann er ausgeschaltet werden
$hGUI = GUICreate("Erstes GUI", 400, 400) ; GUI wird wieder erstellt
GUISetOnEvent($GUI_EVENT_CLOSE, "_Exit") ; Beim Ereignis $GUI_EVENT_CLOSE (-3) also schließen, wird die Func _Exit() aufgerufen
$hInput = GUICtrlCreateInput("", 10, 10, 100, 20) ; Input wird erstellt, Control-ID ist $hInput
$hButton = GUICtrlCreateButton("Lesen", 10, 50, 70, 40) ; Button wird erstellt, Control-ID ist $hButton
GUICtrlSetOnEvent($hButton, "_Auslesen")
GUISetState(@SW_SHOW) ;GUI wird angezeigt
While 1
Sleep(10) ; Skript bleibt in einer Endlosschleife, also Leerlauf
WEnd
Func _Exit() ; _Exit() beendet das Script
Exit
EndFunc
Func _Auslesen() ; _Auslesen() liest den Input aus, und gibt das ausgelesene in der MsgBox wieder zurück
$read = GUICtrlRead($hInput)
MsgBox(0, "Gelesen", "In der Input-Box stand: " & $read)
EndFunc
#include<GUIConstantsEx.au3>; System-Ereignisse werden includet
Opt('GUIOnEventMode',1); OnEventMode wird mit 1 eingeschaltet, mit 0 kann er ausgeschaltet werden
$hGUI=GUICreate("Erstes GUI",400,400); GUI wird wieder erstellt
GUISetOnEvent($GUI_EVENT_CLOSE,"_Exit"); Beim Ereignis $GUI_EVENT_CLOSE (-3) also schließen, wird die Func _Exit() aufgerufen
$hInput=GUICtrlCreateInput("",10,10,100,20); Input wird erstellt, Control-ID ist $hInput
$hButton=GUICtrlCreateButton("Lesen",10,50,70,40); Button wird erstellt, Control-ID ist $hButton
Dieses Kapitel ist schon etwas komplexer. Wenn sie grade ein Anfänger sind, dann hören sie auf, und spielen ein wenig mit Controls herum. Wenn sie jedoch schon etwas Erfahrung in GUIs haben, oder wenigstens in AutoIt, dann können sie getrost weiterlesen.
Es gibt mehrere Möglichkeiten um mehrere GUIs in einem Script zu haben. Dieses Kapitel zeigt zwei von ihnen.
#include <GUIConstantsEx.au3> ;System-Ereignisse werden includet
;GUI wird erstellt und angezeigt
$hGUI = GUICreate("Erste GUI", 400, 400)
GUISetState(@SW_SHOW)
;Message-Loop wartet auf schließen, und öffnet eine neue GUI
While 1
$msg = GUIGetMsg()
Switch $msg
Case $GUI_EVENT_CLOSE
_OpenNewGUI() ; Func wird aufgerufen
EndSwitch
WEnd
Func _OpenNewGUI()
GUIDelete($hGUI) ; $hGUI wird gelöscht, damit neues GUI angezeigt wird
; 2te GUI wird erstellt und angezeigt
$hGUI2 = GUICreate("2te GUI", 400, 400)
GUISetState(@SW_SHOW)
;Message-Loop Schleife. Diesmal wird wirklich beendet.
While 1
$msg = GUIGetMsg()
Switch $msg
Case $GUI_EVENT_CLOSE
Exit
EndSwitch
WEnd
EndFunc
#include<GUIConstantsEx.au3>;System-Ereignisse werden includet
Jetzt kommt die Erklärung: Beim eigentlichen Schließen der GUI wird jetzt nicht Exit ausgeführt, sondern eine Func. Diese Func löscht die vorherige GUI, also sie zerstört es. (GUIDelete). Und erstellt eine neue GUI. Wenn man jetzt noch mal auf schließen drückt, dann beendet sich das Script wirklich.
Der wesentliche Unterschied hier, ist, dass beim Schließen nicht Exit, sonder ExitLoop angewendet wird, dass heißt, die Schleife wird beendet. Da das Skript dort aber nicht zu Ende ist, beendet das Skript sich auch nicht. GUIDelete löscht das GUI wieder. Danach wird ein neues GUI erstellt und angezeigt. Beim Schließen wird dieses mal Exit benutzt.
Das war schon alles vom Tutorial. Vielleicht haben Sie jetzt einen kleinen Überblick, was man alles mit GUIs anfangen kann. Und man kann damit viel anfangen. Ich hoffe es hat Ihnen gefallen. Tutorial geschrieben von Bakku.