W AutoIt podobnie jak w wielu innych językach programowania, można wpływać na działania translatora i jego sposób interpretacji kodu źródłowego. Służą do tego dyrektywy translatora i funkcje konfiguracyjne.

Dyrektywy translatora (interpretera)

Zbiór dostępnych dyrektyw nie jest specjalnie rozbudowany, zawiera tylko 10 pozycji. Każda dyrektywa rozpoczyna od znaku #, po którym następuje nazwa i ewentualne parametry.

Najważniejszą i najczęściej używaną dyrektywą jest:

Polecenie wczytania zewnętrznego kodu

#include "[ścieżka _dostępu\]nazwa_pliku"

lub

#include <nazwa_pliku>

Forma pierwsza może wskazywać plik w dowolnej lokalizacji. Jeżeli pominięta jest ścieżka dostępu to domyślnie przyjmowana jest jako miejsce uruchomienia skryptu.

Forma druga odnosi się do lokalizacji standardowej biblioteki AutoIt (najczęściej jest to C:\Program Files\AutoIt3\Include).

Dzięki dyrektywie #include możemy w programach korzystać z zewnętrznych bibliotek bez konieczności kopiowania kodu do wnętrza tworzonego skryptu.

Oczywiście dołączany kod musi być także napisany w AutoIt. Będzie on wstawiony do skryptu w miejsce dyrektywy.

Z #include ściśle związana jest kolejna dyrektywa:

#include-once

Jeżeli dołączany plik rozpoczyna się tą dyrektywą oznacza to, że może on być dołączony do skryptu tylko raz (w miejscu pierwszego #include). Dyrektywę tą stosuje się w plikach bibliotek. Zabezpiecza to przed błędem "Duplicate function" - ponownym deklarowaniem raz zadeklarowanej funkcji.

Działanie dyrektywy możemy prześledzić na poniższych przykładach:

;skrypt
#include "include_test.au3"
#include "include_test.au3"

;plik dołączany "include_test.au3"
MsgBox(0, "TEST:", "Komunikat testowy")

W tym przykładzie okienko testowe będzie wyświetlone dwa razy.

Jeżeli jednak plik dołączany będzie wyglądał tak:

;plik dołączany "include_test.au3"
#include-once
MsgBox(0, "TEST:", "Komunikat testowy")

to okienko wyświetli się tylko raz (drugie wywołanie #include "include_test.au3" zostanie zignorowane).

Początek i koniec bloku komentarza

#comments-start
...
...
#comments-end

lub w wersji skróconej

#cs
...
...
#ce

Zazwyczaj komentarz rozpoczyna się znakiem średnika (;). Oznacza to, że wszystko co zostało zapisane poczynając od tego znaku, aż do końca wiersza, jest komentarzem i zostanie zignorowane przez translator. Jeżeli chcemy wstawić komentarz wielowierszowy, to zamiast rozpoczynać każdy wiersz średnikiem, możemy użyć powyższych dyrektyw. Translator zignoruje cały blok tekstu poczynając od #comments-start (#cs), a kończąc na #comments-end (#ce).

Początek i koniec bloku programu

#region [nazwa bloku programu]
...
...
...
#endregion [nazwa bloku programu]

Dyrektywy te są ignorowane przez translator i nie powodują żadnego działania w wykonywanym skrypcie. Są jedynie informacją dla edytora, że dany fragment kodu należy traktować jako jeden blok, który przyciśnięciem klawisza myszki można zwinąć do postaci jednego wiersza. Oczywiście operacja ta nie wpływa na zawartość kodu, powoduje tylko, że pewien jego fragment nie będzie wyświetlany. Ułatwia to pracę nad dużymi projektami. Część nieobrabianego aktualnie kodu można czasowo ukryć, dzięki czemu łatwiej nam będzie operować fragmentem aktualnie edytowanym.

Przykład:

#region deklaracje stałych globalnych
Global Const $a=1
Global Const $b=2
Global Const $c=3
#endregion koniec deklaracji stałych globalnych
;dalej dalsza część skryptu

Specjalna dyrektywa kontrolowania kompilacji skryptu

#pragma compile(dyrektywa, parametr)

dyrektywa - rodzaj ustawianego aspektu kompilacji

parametr - parametr dla danej dyrektywy

Dyrektywa           | Parametr            | Opis i przykład
-----------------------------------------------------------------------------------------------
Out                 | Nazwa pliku         | Określenie nazwy pliku wynikowego np.:
                    |                     | #pragma compile(Out, program.exe)
                    |                     | Domyślnie: jak nazwa skryptu z rozszerzeniem .exe
-----------------------------------------------------------------------------------------------
Icon                | Nazwa pliku         | Nazwa pliku ikony programu:
                    |                     | #pragma compile(Icon, ikona.ico)
                    |                     | Domyślnie: standardowa ikona AutoIt
-----------------------------------------------------------------------------------------------
ExecLevel           | none,               | Ustawienie poziomu wykonywania w manifeście
                    | asInvoker,          | skompilowanego pliku wykonywalnego:
                    | highestAvailable,   | #pragma compile(ExecLevel, highestavailable)
                    | requireAdministrator|    
-----------------------------------------------------------------------------------------------
UPX                 | True, False         | Kompresja pliku skompilowanego z użyciem UPX:
                    |                     | #pragma compile(UPX, false) 
-----------------------------------------------------------------------------------------------
AutoItExecuteAllowed| True, False         | Zamiast #NoAutoIt3Execute
                    |                     | #pragma compile(AutoItExecuteAllowed, True)
                    |                     | Domyślnie: False
-----------------------------------------------------------------------------------------------
Console             | True, False         | Kompilacja do wersji konsolowej: 
                    |                     | #pragma compile(Console, True)
                    |                     | Domyślnie: False
-----------------------------------------------------------------------------------------------
Compression         | 1, 2, 5, 7, 9       | Stopień kompresji pliku wynik.:
                    |                     | #pragma compile(Compression, 1)
                    |                     | Domyślnie: 2
-----------------------------------------------------------------------------------------------
Compatibility       | vista, win7         | Kompilacja w trybie zgodności z wersją systemu:
                    | win8, win81         | #pragma compile(Compatibility, win81)
-----------------------------------------------------------------------------------------------
x64                 | True, False         | Czy kompilacja do wersji 64 bitowej:
                    |                     | #pragma compile(x64, True)
                    |                     | Domyślnie: False
-----------------------------------------------------------------------------------------------
Comments            | Komentarz           | Wstawienie tekstu komentarza do skompilowanego pliku:
                    |                     | #pragma compile(Comments, To jest treść "komentarza')
-----------------------------------------------------------------------------------------------
CompanyName         | Nazwa               | Wstawienie nazwy firmy:
                    |                     | #pragma compile(CompanyName, 'Wasta' Co.)
-----------------------------------------------------------------------------------------------
FileDescription     | Opis                | Wstawienie opisu pliku:
                    |                     | #pragma compile(FileDescription, Sktypt w AutoIt)
-----------------------------------------------------------------------------------------------
FileVersion         | Wersja              | Wstawienie numeru wersji pliku:
                    |                     | #pragma compile(FileVersion, 3.3.10.2)
-----------------------------------------------------------------------------------------------
InternalName        | Nazwa               | Wstawienie wewnętrznej nazwy pliku:
                    |                     | #pragma compile(InternalName, "Jakaś nazwa")
-----------------------------------------------------------------------------------------------
LegalCopyright      | Copyright           | Wstawienie uwag o prawach autorskich:
                    |                     | #pragma compile(LegalCopyright, Legal stuff here)
-----------------------------------------------------------------------------------------------
LegalTrademarks     | Opis                | Wstawienie uwag o znakach firmowych:
                    |                     | #pragma compile(LegalTrademarks, 'Znak firmowy')
-----------------------------------------------------------------------------------------------
OriginalFilename    | Nazwa pliku         | Wstawienie nazwy oryginalnego pliku:
                    |                     | #pragma compile(OriginalFilename, MojSkrypt.exe)
-----------------------------------------------------------------------------------------------
ProductName         | Nazwa               | Wstawienie nazwy produktu:
                    |                     | #pragma compile(ProductName, Maszyna co robi PING)
-----------------------------------------------------------------------------------------------
ProductVersion      | Wersja              | Wstawienie numeru wersji produktu:
                    |                     | #pragma compile(ProductVersion, 6.6.6.13)

UWAGA: W parametrze cudzysłowy i apostrofy są traktowane jak zwykłe znaki.

Uruchomienie skryptu z prawami administratora

#RequireAdmin

Dyrektywa informuje translator, że skrypt do uruchomienia wymaga pełnych praw administratora.

Czy komputer działa w trybie administratora można sprawdzić za pomocą funkcji:

IsAdmin

IsAdmin ( )

Funkcja zwraca 1 gdy komputer działa w trybie administratora, w przeciwnym razie zwraca 0.

Przykład:

If IsAdmin() Then MsgBox(0, "Test funkcji IsAdmin()", "Tryb administratora!")

Ukrycie ikony w zasobniku systemowym paska zadań

#NoTrayIcon

Dyrektywa powoduje, że w zasobniku systemowym (tray) paska zadań nie pojawi się ikona wykonywanego skryptu. Można ponownie włączyć ikonę przy użyciu funkcji Opt("TrayIconHide", 0).

Przykład:

#NoTrayIcon
MsgBox(0, "TEST:", "Po zamknięciu okna pojawi się ikona na pasku zadań!")
Opt("TrayIconHide", 0) ;ponowne pokazanie ikont w tray'u
Sleep(5000)

NoAutoIt3Execute

#NoAutoIt3Execute

Dyrektywa określa, że skompilowany skrypt nie może być uruchomiony przez AutoIt3ExecuteLine lub AutoIt3ExecuteScript.

Dyrektywa ta jest nieaktualna od wersji 3.3.12.0. Zastępuje ją #pragma compile(AutoItExecuteAllowed, False), która jest ustawiona domyślnie.

Rejestrowanie funkcji wywoływanej w chwili uruchomienia skryptu

#OnAutoItStartRegister "nazwa_funkcji"

Dyrektywa określa jaka funkcja ma być wywołana w momencie uruchomienia skryptu. Parametrem dyrektywy jest nazwa wywoływanej funkcji.

Jeżeli dyrektywy użyjemy wielokrotnie (z różnymi nazwami funkcji), to funkcje będą wywoływane w kolejności takiej jaka jest kolejność dyrektyw.

Funkcje są wywoływane na samym początku wykonywania skryptu nawet wtedy, gdy dyrektywy nie są na początku kodu skryptu.

Przykład:

MsgBox(16,"SKRYPT:","Segment główny")
#OnAutoItStartRegister "Funkcja1"
#OnAutoItStartRegister "Funkcja2"

Func Funkcja1()
   MsgBox(32, "TEST:", "Funkcja1?")
EndFunc

Func Funkcja2()
   MsgBox(64, "TEST:", "Funkcja2!")
EndFunc

Funkcje OnAutoItExitRegister i OnAutoItExitUnRegister

Omówimy teraz dwie funkcje pokrewne dyrektywie #OnAutoItStartRegister:

OnAutoItExitRegister ( "nazwa_funkcji" )

Funkcja określa (rejestruje) jaka funkcja ma być wywołana w momencie zakończenia skryptu. Zwraca 1 gdy sukces, lub 0 gdy wystąpił błąd.

Parametrem funkcji jest nazwa wywoływanej funkcji.

Jeżeli funkcji użyjemy wielokrotnie (z różnymi nazwami), to funkcje zarejestrowane będą wywoływane w kolejności odwrotnej do kolejności rejestracji.

Przykład:

OnAutoItExitRegister("Funkcja1")
OnAutoItExitRegister("Funkcja2")
Sleep(2000)

;funkcje rejestrowane
Func Funkcja1()
   MsgBox(32, "TEST:", "Funkcja1?")
EndFunc

Func Funkcja2()
   MsgBox(64, "TEST:", "Funkcja2!")
EndFunc

Przykład (z odczytem kodu i metody zakończenia skryptu):

OnAutoItExitRegister("Moja_funkcja")
Exit 666

;funkcja rejestrowana
Func Moja_funkcja()
   MsgBox(32, "TEST:", "Kod wyjścia:   " & @exitCode & @LF & _
	  	       "Metoda wyjścia: " & @exitMethod)
EndFunc

OnAutoItExitUnRegister ( "nazwa_funkcji" )

Funkcja anuluje rejestrację funkcji uruchamianej w momencie zakończenia skryptu. Zwraca 1 gdy sukces, lub 0 gdy wystąpił błąd.

Parametrem funkcji jest nazwa funkcji, której rejestracja jest anulowana.

Przykład:

OnAutoItExitRegister("Funkcja1")
OnAutoItExitRegister("Funkcja2")
Sleep(2000)
OnAutoItExitUnRegister("Funkcja1")

;funkcje rejestrowane
Func Funkcja1()
   MsgBox(32, "TEST:", "Funkcja1?")
EndFunc

Func Funkcja2()
   MsgBox(64, "TEST:", "Funkcja2!")
EndFunc

Funkcje AdlibRegister i AdlibUnRegister

Obie funkcje nie zwracają żadnej wartości.

AdlibRegister ( "nazwa_funkcji" [, czas] )

Funkcja rejestruje inną funkcję (tzw. Adlib), która będzie wywoływana co określony przedział czasu, do zakończenia działania skryptu, lub do odwołania rejestracji.

"nazwa_funkcji" - nazwa rejestrowanej funkcji.

czas - (opcjonalnie) czas w ms między kolejnymi wywołaniami zarejestrowanej funkcji, domyślnie 250 ms.

UWAGA:

Rejestrowana funkcja powinna być prosta, jeżeli jest wywoływana często gdyż w czasie jej działania wykonanie głównego skryptu zostaje wstrzymane. Również parametr czasu należy stosować ostrożnie, aby uniknąć zbytniego obciążenia procesora.

Można zarejestrować kilka funkcji, ale nie można zarejestrować funkcji używającej parametrów.

AdlibUnRegister ( ["nazwa_funkcji"] )

Funkcja wyrejestrowuje funkcję Adlib.

"nazwa_funkcji" - (opcjonalnie) nazwa wyrejestrowywanej funkcji, domyślnie wyrejestrowane zostaną wszystkie funkcje Adlib.

Przykład:

AdlibRegister("FAdlib",500)
SplashTextOn("Test funkcji AdlibRegister","Włączona",200,50)
Sleep(10000)
AdlibUnRegister()
SplashTextOn("Test funkcji AdlibRegister","Wyłączona",200,50)
Sleep(5000)

Func FAdlib()
   Beep(1000,200)
EndFunc

Funkcja Break

Break ( mod )

Funkcja włącza lub wyłącza możliwość przerwania działania skryptu za pomocą opcji Exit menu kontekstowego ikony w tray'u. Nie zwraca żadnej wartości.

mod = 1 - (domyślne) funkcja Braek włączona, w menu jest pozycja Exit

mod = 0 - funkcja Braek wyłączona, w menu nie ma pozycji Exit

Przykład:

Break(0) ;break wyłączony
MsgBox(0,"Test","Break Off",10)
Break(1) ;break włączony
MsgBox(0,"Test","Break On")
Do
   Beep()
   Sleep(50)
Until False

Funkcje konfiguracyjne

Funkcje te służą do zmiany sposobu działania niektórych innych funkcji. Wszystkie mają następującą ogólną postać:

AutoItSetOption ( "opcja" [, par] )

lub w wersji skróconej:

Opt ( "opcja" [, par] )

"opcja" - nazwa opcji określająca sposób oddziaływania funkcji.

par - parametr przypisany do danej opcji, jego znaczenie zależy od rodzaju opcji. Jeżeli go pominiemy, funkcja tylko zwróci aktualną wartość parametru nie zmieniając jego wartości. Default przywraca domyślną wartość.

Funkcje zwraca poprzednią wartość parametru par. Jeżeli wystąpi błąd (np. podano złe wartości parametrów) to makro @error przyjmie niezerową wartość.

Opt("CaretCoordMode", par)

Określa sposób traktowania współrzędnych ekranowych karetki (kursor tekstowy):

par = 0 - współrzędne względne do aktywnego okna

par = 1 - współrzędne bezwzględne całego ekranu (wartość domyślna)

par = 2 - współrzędne względne do obszaru roboczego aktywnego okna (pominięta ramka i belka)

Opt("ExpandEnvStrings", par)

Określa jak mają być interpretowane w łańcuchach (stringach) znaki %.

par = 0 - jak zwykłe znaki (wartość domyślna)

par = 1 - jak początek nazwy zmiennej środowiskowej, której wartość zostanie wstawiona do stringu w miejsce nazwy, nazwę należy zakończyć tym samym znakiem, np.: %temp%

Opt("ExpandVarStrings", par)

Określa jak mają być interpretowane w łańcuchach (stringach) znaki $ i @.

par = 0 - jak zwykłe znaki (wartość domyślna)

par = 1 - jak początek nazwy zmiennej (makra), której wartość zostanie wstawiona do stringu w miejsce nazwy, nazwę należy zakończyć tym samym znakiem, np.: $nazwa_zmiennej$, @hour@

Przykład:

Opt("ExpandVarStrings", 1)
$a=3.1415
MsgBox(0,"","a = $a$") ;wyświetli "a = 3.1415"
Opt("ExpandVarStrings", 0)
MsgBox(0,"","a = $a$") ;wyświetli "a = $a$"

Opt("GUICloseOnESC", par)

Ustala czy wciśnięcie klawisza ESC ma wysyłać wartość $GUI_EVENT_CLOSE, tak jak wciśnięcie przycisku zamknięcia okna.

par = 0 - nie

par = 1 - tak (wartość domyślna)

Opt("GUICoordMode", par)

Ustala system współrzędnych używanych przez GUICtrlSetPos.

par = 0 - współrzędne względne w stosunku do położenia poprzednio ustawionej kontrolki

par = 1 - współrzędne bezwzględne okna GUI

par = 2 - przesunięcie o offset (offsetem jest wielkość ostatnio zdefiniowanej kontrolki)

Przy tym ustawieniu współrzędne kontrolki oznaczają:

-1  - brak przesunięcia w danej osi
0   - przesunięcie o offset (w dól i w prawo)
>0  - dodatkowe przesunięcie w stosunku do offsetu w dól i w prawo (w pikselach)
<-1 - dodatkowe przesunięcie w stosunku do offsetu w górę i w lewo (w pikselach)

Przykład dla par=2:

#include <GUIConstantsEx.au3>
Opt("GUICoordMode", 2)
GUICreate("Test Opt (GUICoordMode,2)")
$button = GUICtrlCreateButton("-1-", 100, 50,100,20)

For $i=2 to 15
   GUICtrlCreateButton("-"&$i&"-",-1,0)
Next
GUICtrlCreateButton("-16-",0,-1)

For $i=14 to 27
   GUICtrlCreateButton("-"&$i&"-",-1,-40)
Next

GUISetState()
Do
Until GUIGetMsg()=$GUI_EVENT_CLOSE

Opt("GUIDataSeparatorChar", par)

Ustala jaki znak będzie separatorem danych w funkcji GUICtrlSetData.

par = znak który ma być separatorem (domyślnie pionowa kreska "|").

Opt("GUIOnEventMode", par)

Ustala czy mają działać funkcje GUI...OnEvent (GUISetOnEvent, GUICtrlSetOnEvent).

par = 0 - nie działają (wartość domyślna)

par = 1 - działają (Uwaga: blokowane jest działanie funkcji GUIGetMsg).

Opt("GUIResizeMode", par)

Ustala domyślną wartość parametru określającego sposób reagowania kontrolek na zmianę wielkości okna, a używanego przez funkcję GUICtrlSetResizing.

par = 0 - wartość domyślna

par = (od 1 do 1023) - zakres możliwych wartości (patrz opis funkcji GUICtrlSetResizing.

Opt("GUIEventOptions", par)

Reagowanie okna na próbę minimalizacji, maksymalizacji, przywrócenia lub zmiany rozmiarów.

par = 0 - reaguje (wartość domyślna)

par = 1 - nie reaguje

Opt("MouseClickDelay", par)

Określa czas przerwy między kolejnymi kliknięciami klawiszy myszki (w symulacjach użycia myszki).

par = czas przerwy w milisekundach (wartość domyślna 10)

Opt("MouseClickDownDelay", par)

Określa czas przytrzymania klawisza myszki (w symulacjach użycia myszki).

par = czas przytrzymania w milisekundach (wartość domyślna 10)

Opt("MouseClickDragDelay", par)

Czas przerwy na początku i końcu operacji przeciągania myszką (funkcja MouseClickDrag).

par = czas przerwy w milisekundach (wartość domyślna 250)

Opt("MouseCoordMode", par)

Ustala system współrzędnych w funkcjach związanych z użyciem myszki.

par = 0 - współrzędne względne do aktywnego okna

par = 1 - współrzędne bezwzględne całego ekranu (wartość domyślna)

par = 2 - współrzędne względne do obszaru roboczego aktywnego okna (pominięta ramka i belka)

Opt("MustDeclareVars", par)

Określa czy konieczne jest deklarowanie zmiennych poprzez Dim, Local lub Global.

par = 0 - deklaracja nie jest konieczna (wartość domyślna)

par = 1 - deklaracja jest konieczna, użycie niezadeklarowanej zmiennej spowoduje wystąpienie błędu.

Opt("PixelCoordMode", par)

Ustala system współrzędnych w funkcjach związanych z odczytem wartości pikseli (PixelGetColor, PixelChecksum, PixelSearch).

par = 0 - współrzędne względne do aktywnego okna

par = 1 - współrzędne bezwzględne całego ekranu (wartość domyślna)

par = 2 - współrzędne względne do obszaru roboczego aktywnego okna (pominięta ramka i belka)

Opt("SendAttachMode", par)

Określa działanie następnych funkcji Send().

par = 0 (domyślnie) dla Windows NT4 rozpoznanie użycia klawiszy CapsLock / ScrollLock i NumLock może być zawodne

par = 1 nie jest rozpoznawane Send ("{... down / up}")

UWAGA: Funkcja w zasadzie nie ma zastosowania w nowszych wersjach Windows. Nie ma także wpływu na funkcję ControlSend().

Opt("SendCapslockMode", par)

Określa czy AutoIt ma zapamiętywać i następnie odtwarzać stan klawisza CapsLock po użyciu symulacji klawiatury.

par = 0 - nie zapamiętuje

par = 1 - zapamiętuje i odtwarza (wartość domyślna)

Opt("SendKeyDelay", par)

Określa czas przerwy między kolejnymi wciśnięciami klawiszy (w symulacjach użycia klawiatury).

par = czas przerwy w milisekundach (wartość domyślna 5)

Opt("SendKeyDownDelay", par)

Określa czas przytrzymania klawisza (w symulacjach użycia klawiatury).

par = czas przytrzymania w milisekundach (wartość domyślna 5)

Opt("TCPTimeout", par)

Limit czasu dla funkcji TCP. Po tym czasie funkcja zostanie zakończona automatycznie, jeżeli nie następuje wymiana danych.

par = czas w milisekundach (domyślnie 100 ms)

Opt("TrayAutoPause", par)

Ustala czy działanie skryptu ma być wstrzymane po kliknięciu ikony w zasobniku systemowym (tray).

par = 0 - nie wstrzymane

par = 1 - wstrzymywane (wartość domyślna)

Opt("TrayIconDebug", par)

Ustala czy na etykietce nad ikoną skryptu w zasobniku systemowym, ma być wyświetlana aktualnie wykonywana linia kodu.

par = 0 - nie wyświetlana (wartość domyślna)

par = 1 - wyświetlana

Opt("TrayIconHide", par)

Ustala czy ikona skryptu w zasobniku systemowym ma być widoczna czy ukryta.

par = 0 - widoczna (wartość domyślna)

par = 1 - ukryta (po 750 ms)

Opt("TrayMenuMode", par)

Ustala zawartość menu związanego z ikoną skryptu w zasobniku systemowym (można sumować wartości).

par = 0 - (wartość domyślna) domyślne elementy menu (Script Paused/Exit) są dołączane do menu użytkownika

par = 1 - bez domyślnego menu

par = 2 - elementy menu stworzone przez użytkownika nie będą automatycznie zaznaczane po kliknięciu na nie

par = 4 - dwukrotne kliknięcie na ikonie w zasobniku nie powoduje wybrania domyślnej pozycji menu

par = 8 - można zaznaczyć więcej niż jeden przycisk radio w menu zasobnika (o ile takie istnieją)

Przykład (aby zobaczyć różnice należy usunąć średnik z przed Opt("TrayMenuMode", 1), a wstawić przed Opt("TrayMenuMode", 5).

#include <Constants.au3>

Opt("TrayOnEventMode", 1) ;użycie przechwytywania zdarzeń w zasobniku

;Opt("TrayMenuMode", 1) ;bez standardowych pozycji menu
Opt("TrayMenuMode", 5) ;bez wybierania pozycji po dwukliku na ikonie

HotKeySet("{ESC}", "Tray_Exit") ;klawisz skrótu do zakończenia skryptu

$h_1 = TrayCreateItem("Pozycja 1")
TrayItemSetOnEvent($h_1, "Funkcja_1")
TrayCreateItem("")
$h_2 = TrayCreateItem("Pozycja 2")
TrayItemSetOnEvent($h_2, "Funkcja_2")
TrayItemSetState($h_2, $TRAY_DEFAULT) ;domyślna pozycja menu

TraySetState()

Do
    Sleep(10)
Until False


Func Funkcja_1()
    ConsoleWrite("Pozycja 1" & @CRLF)
EndFunc

Func Funkcja_2()
    ConsoleWrite("Pozycja 2" & @CRLF)
EndFunc

Func Tray_Exit()
    Exit
EndFunc

Opt("TrayOnEventMode", par)

Ustala czy mają działać funkcje Tray...OnEvent (TraySetOnEvent, TrayItemSetOnEvent).

par = 0 - nie działają (wartość domyślna)

par = 1 - działają

Opt("WinDetectHiddenText", par)

Ustala czy tekst w ukrytych oknach ma być widoczny dla funkcji przeszukujących okna (np. WinGetText)

par = 0 - nie wykrywa tekstu ukrytego (wartość domyślna)

par = 1 - wykrywa tekst ukryty

Opt("WinSearchChildren", par)

Ustala sposób działania procedur wyszukiwania okien.

par = 0 - uwzględnia tylko okna najwyższego poziomy (wartość domyślna)

par = 1 - uwzględnia także okna potomne (child)

Opt("WinTextMatchMode", par)

Ustala metodę, która jest używana w celu dopasowania tekstu w oknie podczas operacji wyszukiwania.

par = 1 - pełna (wartość domyślna), metoda dokładniejsza (rozpoznaje np. teksty w polach edytora), ale powolniejsza

par = 2 - szybka. W tej metodzie AutoIt widzi tylko nazwę okna, tekst na przyciskach i opisy na niektórych kontrolkach. Metoda polecana przy kłopotach z wydajnością.

Opt("WinTitleMatchMode", par)

Określa sposób dopasowania nazwy okna (rozdział 4.1.1 Nazwy okien: AutoIt/Przejmowanie kontroli).

par = 1 - dopasowanie do dowolnej części początku nazwy okna (wartość domyślna)

par = 2 - dopasowanie do dowolnej części nazwy okna

par = 3 - dopasowanie dokładne

Jeżeli podamy wartości ujemne zamiast dodatnich to w nazwie okna nie będą rozróżniana wielkość liter.

Przykład:

Opt("WinTitleMatchMode", 2)
$pid=Run("notepad.exe")
ProcessWait($pid)
Sleep(500)
MsgBox(0,"",WinExists("nOTa")) ;wyświetli 0, okno nie istnieje
Opt("WinTitleMatchMode", -2)
MsgBox(0,"",WinExists("nOTa")) ;wyświetli 1, okno istnieje
ProcessClose($pid)

Opt("WinWaitDelay", par)

Określa czas wstrzymania skryptu w czasie wykonywania operacji na oknach (otwieranie, zamykanie itp.).

par = czas wstrzymania w milisekundach (wartość domyślna 250)

Dyrektywy wrappera

Dyrektywy wrappera służą do ustawienia opcji pracy kompilatora lub edytora SciTE.

Dyrektywy edytora

#AutoIt3Wrapper_Run_Debug_Mode= [ N / Y ]

Czy uruchomić skrypt z konsolą debugowania. Domyślna wartość: N (czyli nie).

#AutoIt3Wrapper_Run_SciTE_Minimized= [ N / Y ]

Czy minimalizować okno edytora podczas działania skryptu. Domyślna wartość: N (czyli nie).

#AutoIt3Wrapper_Run_SciTE_OutputPane_Minimized= [N / Y]

Czy ukryć okienko wyjściowe edytora (to w dolnej części okna edytora). Domyślna wartość: N (czyli nie).

#AutoIt3Wrapper_Run_Tidy= [ N / Y ]

Czy włączyć standardowe formatowanie kody. Domyślna wartość: N (czyli nie).

Dyrektywy kompilatora

#AutoIt3Wrapper_UseX64= [ N / Y ]

Czy kompilować skrypt w wersji 64-bitowej. Domyślna wartość: N (czyli skrypt zostanie skompilowany w wersji 32-bitowej).

#AutoIt3Wrapper_Icon= [ nazwa pliku ikony ]

Ustalenie jaką ikonę ma mieć skompilowany skrypt. Jeżeli nie podamy będzie to standardowa ikona AutoIt.

#AutoIt3Wrapper_OutFile= [ nazwa pliku wynikowego ]

Jeżeli nie podamy plik wynikowy będzie miał taką samą nazwę jak plik źródłowy, z rozszerzeniem EXE lub A3X.

#AutoIt3Wrapper_OutFile_Type= [ a3x / exe ]

Typ wynikowego pliku, a3x - skompresowany plik źródłowy, exe - plik wykonywalny. Domyślnie: exe.

#AutoIt3Wrapper_OutFile_X64= [ nazwa pliku wynikowego ]

Nazwa pliku dla wersji 64-bitowej pliku exe.

#AutoIt3Wrapper_Compression= [ 0 / 1 / 2 / 4 ]

Stopień kompresji pliku wynikowego, 0 - bez kompresji, 1 - niski, 2 - normalny, 4 - wysoki. Domyślnie: 2.

#AutoIt3Wrapper_UseUpx= [ N / Y ]

Czy wynikowy plik ma być skompresowany. Domyślnie: Y (czyli tak).

#AutoIt3Wrapper_Change2CUI= [ N / Y ]

Zmiana wyjścia skryptu z GUI na konsolę (wersja konsolowa skryptu). Domyślnie: N (czyli wyjście na GUI).

#AutoIt3Wrapper_Compile_both= [ N / Y ]

Kompilacja do dwu wersji 32 i 64-bitowej, w jednym przebiegu. Domyślna wartość: N (czyli nie).

#AutoIt3Wrapper_Res_SaveSource= [ N / Y ]

Czy umieścić kopię kodu źródłowego wewnątrz pliku EXE. Domyślna wartość: N (czyli nie).

#AutoIt3Wrapper_Run_AU3Check= { N / Y ]

Sprawdzanie poprawności kodu przed uruchomieniem i kompilacją. Domyślna wartość Y (czyli tak).

#AutoIt3Wrapper_Run_Before= proces1 [ proces2 [...]]                    
#AutoIt3Wrapper_Run_After=  proces1 [ proces2 [...]]

Procesy uruchamiane przed i po kompilacji. Mogą być sekwencje uruchamiane w kolejności wpisów. W opisie procesów można używać zmiennych systemowych:

%in% , %out%, %outx64%, %icon% - nazwy plików, źródłowego, wynikowego i ikony (łącznie z pełną ścieżką dostępu)

%scriptdir%, %scriptfile% - folder i plik źródłowy (łącznie z rozszerzeniem)

%fileversion% - wersja pliku nadana przez #AutoIt3Wrapper_Res_Fileversion=

%scitedir% - folder edytora SciTE

%autoitdir% - folder programu AutoIt3

Dodatkowe informacje wewnątrz pliku EXE

#AutoIt3Wrapper_Res_Comment= [ treść komentarza ]
#AutoIt3Wrapper_Res_Description= [ treść opisu ]
#AutoIt3Wrapper_Res_Fileversion= [ wersja pliku ]
#AutoIt3Wrapper_Res_ProductVersion= [ wersja produktu ]
#AutoIt3Wrapper_Res_Language= [ kod języka ] - domyślnie 2057=angielski
#AutoIt3Wrapper_Res_LegalCopyright= [ autor ]

#AutoIt3Wrapper_Res_Field= nazwa pola|wartość

Dodatkowe pola z informacjami. Może być ich maksymalnie 15. Można używać zmiennych systemowych:

%AutoItVer% - wersja AutoIt'a

%date% - data (format krótki)

%longdate% - data (format długi)

%time% - czas

Przykład:

#AutoIt3Wrapper_Res_Field=Wesja AutoIt|%AutoItVer%
#AutoIt3Wrapper_Res_Field=Data|%date%
;dalsza część programu

Dodatkowe pliki wewnątrz pliku EXE

#AutoIt3Wrapper_Res_Icon_Add= nazwa_pliku_ikony[,nr_ikony]

Dołączenie dodatkowych ikon do pliku EXE. Jeżeli nie podamy nr_ikony to numeracja będzie w kolejności wpisów (numeracja rozpoczyna się od 5!).

Przykład:

#AutoIt3Wrapper_Res_Icon_Add=C:\I1.ico ;ikona 5
#AutoIt3Wrapper_Res_Icon_Add=C:\I2.ico ;ikona 6
;dalsza część programu

#AutoIt3Wrapper_Res_File_Add=nazwa_pliku[,sekcja[,nazwa_zasobu[,nr_pliku]]]

Dołączenie dodatkowego pliku do pliku EXE.

Przykład:

#AutoIt3Wrapper_Res_File_Add=images\background.png, 10, bkg.png_1
#AutoIt3Wrapper_Res_File_Add=images\childbkg.png, 10, childbkg.png_1
#AutoIt3Wrapper_Res_File_Add=images\logo.png, 10, logo1.png_1
#AutoIt3Wrapper_Res_File_Add=images\about.bmp, 10, about.bmp_1