AutoIt/Biblioteki DLL
Co to są biblioteki DLL?
[edytuj]Za Wiki:
DLL (z ang. Dynamic-Link Library - biblioteka łączona dynamicznie) – w środowisku Microsoft Windows biblioteka współdzielona (z ang. shared library), która przechowuje implementacje różnych podprogramów programu lub zasoby programu. Podprogramy i zasoby zawarte w bibliotece DLL mogą być wykorzystane bezpośrednio lub pośrednio (za pośrednictwem innej biblioteki DLL) przez dowolny plik wykonywalny, sama biblioteka DLL nie jest samodzielnym programem.
Funkcje biblioteki dynamicznej (DLL) mogą być jednocześnie (w tym samym czasie) importowane przez wiele programów (stąd określenie: biblioteka współdzielona), dzięki temu pamięć operacyjna jest mniej obciążona. Biblioteki DLL mogą być importowane statycznie bądź dynamicznie. W przeciwieństwie do bibliotek statycznych, które są łączone z programem w czasie jego konsolidowania, biblioteki DLL importowane dynamicznie są oddzielnym fragmentem programu i ich modyfikacja nie wymaga przeprowadzenia ponownej konsolidacji, jednak problem z biblioteką (brak importowanych funkcji lub problem z wczytywaniem biblioteki) całkowicie uniemożliwia uruchomienie programu. Biblioteki importowane dynamicznie są wczytywane do pamięci operacyjnej dopiero w momencie określonym przez programistę (przeważnie gdy faktycznie są potrzebne) - stąd określenie: biblioteka dynamicznie łączona - przez co pliki DLL często są wykorzystywane w różnych programach jako wtyczki.
W systemie Microsoft Windows biblioteki DLL mają rozszerzenia .dll, .ocx (gdy biblioteka jest kontrolką ActiveX), .cpl (gdy biblioteka jest rozszerzeniem Panelu Sterowania), .drv (gdy jest przestarzałym sterownikiem), i mogą być wykorzystane w programach napisanych w różnych językach przeznaczonych na platformę Windows.
W AutoIt nie można tworzyć własnych bibliotek DLL (DLL można tworzyć tylko w językach kompilowanych takich jak C, C++, C#, D, VB, Delphi itp.), można za to korzystać z gotowych bibliotek.
W zasadzie większość funkcji AutoIt”a to nakładki na funkcje DLL systemu operacyjnego (np. wszystkie funkcje GUI).
DllCall
[edytuj]Wywołanie funkcji z biblioteki dynamicznej DLL.
DllCall ("dll", "typ_zwracany", "funkcja" [, typ1, param1 [, typN, paramN]])
Parametry:
dll - nazwa używanego pliku DLL. np. "user32.dll". Może być użyty uchwyt uzyskany funkcją DllOpen (patrz uwagi).
typ_zwracany - zwracany typ funkcji (patrz niżej).
funkcja - nazwa funkcji wywoływanej (np. "MessageBox") lub jej numer porządkowy (np. 62) w bibliotece DLL.
typ1 - [opcjonalnie] typ parametru 1 (patrz uwagi).
param1 - [opcjonalnie] wartość parametru 1 (patrz uwagi).
...
typN - [opcjonalnie] typ n-tego parametru (patrz uwagi).
paramN - [opcjonalnie] wartość n-tego parametru (patrz uwagi).
Prawidłowe typy:
Typ | Szczegóły
--------------------------------------------------------------------------------
none | żadna wartość (tylko dla wartości zwracanej - odpowiednik void w C)
--------------------------------------------------------------------------------
BYTE | 8 bitowa (1 bajt) liczba całkowita bez znaku
--------------------------------------------------------------------------------
BOOLEAN | 8 bitowa (1 bajt) liczba całkowita bez znaku
--------------------------------------------------------------------------------
short | 16 bitowa (2 bajty) liczba całkowita ze znakiem
--------------------------------------------------------------------------------
USHORT | 16 bitowa (2 bajty) liczba całkowita bez znaku
--------------------------------------------------------------------------------
WORD | 16 bitowa (2 bajty) liczba całkowita bez znaku
--------------------------------------------------------------------------------
int | 32 bitowa (4 bajty) liczba całkowita ze znakiem
--------------------------------------------------------------------------------
long | 32 bitowa (4 bajty) liczba całkowita ze znakiem
--------------------------------------------------------------------------------
BOOL | 32 bitowa (4 bajty) liczba całkowita ze znakiem
--------------------------------------------------------------------------------
UINT | 32 bitowa (4 bajty) liczba całkowitą bez znaku
--------------------------------------------------------------------------------
ULONG | 32 bitowa (4 bajty) liczba całkowitą bez znaku
--------------------------------------------------------------------------------
DWORD | 32 bitowa (4 bajty) liczba całkowitą bez znaku
--------------------------------------------------------------------------------
INT64 | 64 bitowa (8 bajtów) liczba całkowita ze znakiem
--------------------------------------------------------------------------------
UINT64 | 64 bitowa (8 bajtów) liczba całkowita bez znaku
--------------------------------------------------------------------------------
ptr | ogólny wskaźnik, 32 lub 64 bitowa liczba całkowita bez znaku
| (w zależności od wersji AutoIt - x86 lub x64)
--------------------------------------------------------------------------------
HWND | uchwyt okna (wskaźnik), 32 bitowa liczba całkowita
--------------------------------------------------------------------------------
HANDLE | uchwyt (wskaźnik), 32 bitowa liczba całkowita
--------------------------------------------------------------------------------
float | 32 bitowa liczba zmiennoprzecinkowa
--------------------------------------------------------------------------------
double | 64 bitowa liczba zmiennoprzecinkowa podwójnej precyzji
--------------------------------------------------------------------------------
INT_PTR | liczba całkowita wystarczająco duża, aby przechowywać wskaźnik
LONG_PTR | (32 lub 64 bitowy, zależnie od wersji AutoIt)
LRESULT |
lParam |
UINT_PTR |
ULONG_PTR |
DWORD_PTR |
WPARAM |
--------------------------------------------------------------------------------
str | string ANSI (maksymalnie 65536 znaków)
--------------------------------------------------------------------------------
wstr | string UNICODE (maksymalnie 65536 znaków)
--------------------------------------------------------------------------------
struct | struktura stworzona przez DllStructCreate()
--------------------------------------------------------------------------------
* | dodanie * na końcu opisu typu oznacza przekazanie parametru
| przez referencję (np. "int*")
--------------------------------------------------------------------------------
Konwersje z typów systemu Windows API do typów AutoIt:
Typ API | Typ AutoIt -------------------------------------------------------------------------------- LPCSTR / LPSTR | str -------------------------------------------------------------------------------- LPCWSTR / LPWSTR | wstr -------------------------------------------------------------------------------- LPVOID | ptr -------------------------------------------------------------------------------- LPxyz | xyz* -------------------------------------------------------------------------------- HINSTANCE | handle -------------------------------------------------------------------------------- HRESULT | long -------------------------------------------------------------------------------- LONGLONG / LARGE_INTEGER | INT64 -------------------------------------------------------------------------------- ULONGLONG / ULARGE_INTEGER | UINT64 SIZE_T | ULONG_PTR
Zwracana wartość:
Sukces: tablica wyników:
$array [0] = wartość zwracana przez funkcję
$array [1] = param1
$array [2] = param2
...
$array [n] = paramN
@error = 0.
Błąd: makro @error przyjmuje wartość:
1 nie można użyć pliku DLL
2 nieznany "typ_zwracany"
3 "funkcja" nie znajduje się w pliku DLL
4 zła ilość parametrów
5 zły parametr
Uwagi:
Jeżeli podamy nazwę pliku DLL, biblioteka jest ładowana automatycznie, a następnie zamykana po zakończeniu wywołania.
Jeśli chcemy ręcznie sterować ładowaniem DLL należy użyć funkcji DllOpen i DllClose, oraz używać uchwyt zamiast nazwy pliku.
Aby móc korzystać z bibliotek DLL należy dokładnie poznać sposób wywoływania zawartych w nich funkcji. Dla bibliotek systemowych Windows bardzo pomocna będzie witryna MSDN.
- http://msdn.microsoft.com/en-us/windows/desktop - Strona MSDN
- http://msdn.microsoft.com/en-us/library/aa383686%28VS.85%29.aspx - Strona MSDN Functions by Category
DllCallAddress
[edytuj]Dynamiczne wywołanie funkcji pod określonym adresem pamięci.
DllCallAddress ("typ_zwracany", adres [, typ1, param1 [, typN, paramN]])
Opis jak dla DllCall().
Ostrzeżenie: Jest to zaawansowana funkcja. Niepoprawne użycie może spowodować awarię Autoita.
Przed skorzystaniem z tej funkcji upewnij się, że musisz jej użyć ponieważ DllCall() nie robi tego, czego oczekujesz.
DllOpen
[edytuj]Otwiera plik DLL do użycia przez DllCall.
DllOpen ("nazwa_pliku")
Parametry:
nazwa_pliku - nazwa otwieranego pliku DLL.
Wartość zwracana:
Sukces: uchwyt (handle) do biblioteki DLL.
Błąd: -1
Uwagi:
Po zakończeniu pracy z biblioteką DLL, należy zamknąć ją przy użyciu funkcji DllClose.
Autoita wprawdzie zamyka wszystkie pliki po zakończeniu działania skryptu, ale lepiej jawnie użyć DllClose.
DllClose
[edytuj]Zamyka wcześniej otwarty DLL.
DllClose (dll_handle)
Parametry: dll_handle - uchwyt do DLL, zwracany przez wywołaną wcześniej funkcję DllOpen.
Funkcja nie zwraca żadnej wartości.
Przykład (wywołanie MsgBox bezpośrednio z DLL):
Local $dll = DllOpen("user32.dll")
Local $result = DllCall($dll, "int", "MessageBox", "hwnd", 0, "str", "Nazwa okna", "str", "Jakiś tekst", "int", 0)
DllClose($dll)
Co to jest struktura?
[edytuj]Struktura lub rekord - to złożony typ danych występujący w wielu językach programowania, grupujący logicznie powiązane ze sobą dane różnego typu w jednym obszarze pamięci. Składowe struktury - pola - są etykietowane, tj. mają swoje unikatowe nazwy; poprzez podanie nazwy otrzymuje się dostęp do danego pola.
Struktury są wykorzystywane między innymi do wymiany danych pomiędzy skryptem, a funkcjami DLL.
Ponieważ AutoIt w zasadzie nie zawiera typu rekordowego danych, struktury nie są tworzone bezpośrednio, lecz za pośrednictwem odpowiedniej funkcji (DllStructCreate()) i stringu z opisem ich budowy. Także manipulowanie strukturami odbywa się za pośrednictwem specjalnie przeznaczonych do tego funkcji.
DllStructCreate
[edytuj]Tworzy strukturę danych w stylu C / C + +, do zastosowania w wywołaniu DllCall.
DllStructCreate (struktura [, wskaźnik])
Parametry:
struktura - ciąg znaków reprezentujący tworzoną strukturę (patrz uwagi).
wskaźnik - [opcjonalnie] wskaźnik do tworzonej struktury danych, jeżeli strukturę chcemy stworzyć w określonym miejscu pamięci.
Wartość zwracana:
Sukces: string ze strukturą do użycia w wywołaniach DllStruct (@error = 0)
Błąd: 0 (makro @error przyjmie wartość:)
1 – wartość przekazana do DllStructCreate nie jest łańcuchem (stringiem)
2 - nieznany typ danych w przetwarzanym łańcuchu
3 - nie udało się przydzielić pamięci potrzebnej do struktury lub pointer = 0
4 - błąd przydzielania pamięci dla przetwarzanego łańcucha
Typ | Szczegóły
--------------------------------------------------------------------------------
BYTE | 8 bitowa liczba całkowita bez znaku
--------------------------------------------------------------------------------
BOOLEAN | 8 bitowa liczba całkowita bez znaku
--------------------------------------------------------------------------------
CHAR | 8 bitowy kod ASCII
--------------------------------------------------------------------------------
WCHAR | 16 bitowy kod UNICODE
--------------------------------------------------------------------------------
short | 16 bitowa liczba całkowita ze znakiem
--------------------------------------------------------------------------------
USHORT | 16 bitowa liczba całkowita bez znaku
--------------------------------------------------------------------------------
WORD | 16 bitowa liczba całkowita bez znaku
--------------------------------------------------------------------------------
int | 32 bitowa liczba całkowita ze znakiem
--------------------------------------------------------------------------------
long | 32 bit liczba całkowita ze znakiem
--------------------------------------------------------------------------------
BOOL | 32 bit liczba całkowita ze znakiem
--------------------------------------------------------------------------------
UINT | 32 bitowa liczba całkowita bez znaku
--------------------------------------------------------------------------------
ULONG | 32 bitowa liczba całkowita bez znaku
--------------------------------------------------------------------------------
DWORD | 32 bitowa liczba całkowita bez znaku
--------------------------------------------------------------------------------
Int64 | 64 bitowa liczba całkowita ze znakiem
--------------------------------------------------------------------------------
UINT64 | 64 bitowa liczba całkowita bez znaku
--------------------------------------------------------------------------------
ptr | 32 lub 64 bitowa całkowita bez znaku
| (w zależności od wersji AutoIt - x86 lub x64)
--------------------------------------------------------------------------------
HWND | 32 bitowa liczba całkowita
--------------------------------------------------------------------------------
HANDLE | 32 bitowa liczba całkowita
--------------------------------------------------------------------------------
float | 32 bitowa liczba zmiennoprzecinkowa
--------------------------------------------------------------------------------
double | 64 bitowa liczba zmiennoprzecinkowa
--------------------------------------------------------------------------------
INT_PTR | 32 lub 64 bitowa całkowita bez znaku
LONG_PTR | (w zależności od wersji AutoIt - x86 lub x64)
LRESULT |
lParam |
--------------------------------------------------------------------------------
UINT_PTR | 32 lub 64 bitowa całkowita bez znaku
ULONG_PTR | (w zależności od wersji AutoIt - x86 lub x64)
DWORD_PTR |
WPARAM |
--------------------------------------------------------------------------------
Uwagi:
Każdy typ danych musi być oddzielony średnikiem ';'.
Możliwe jest tworzenie tablic poprzez dodanie "[rozmiar]" po typie danych, np.: DllStructCreate ("int; char [128]").
Nazwę elementu można dodać podobnie do deklaracji w C, np. : DllStructCreate ("int n; char buffer[128]").
Tą nazwę można używać w następnych wywołaniach funkcji DllStruct … Nazwa może składać się jedynie ze znaków alfanumerycznych i podkreślenia.
Aby zwolnić przydzieloną pamięć wystarczy ustawić zmienną na 0.
Przykład tworzenia struktur:
;struktura bez nazw elementów
$struct1=DllStructCreate("int; char[16]; ptr; byte")
;struktura z nazwami elementów
$struct2=DllStructCreate("int n; char s_1[16]; ptr p1; byte l")
DllStructSetData
[edytuj]Nadaje wartość elementowi w strukturze.
DllStructSetData (struktura, element, wartość [, indeks])
Parametry:
struktura - struktura danych zwrócona przez DllStructCreate.
element - do którego elementu struktury chcemy uzyskać dostęp, nr elementu (numeracja od 1) lub nazwa zdefiniowana w DllStructCreate.
wartość - nowa wartość elementu struktury.
indeks - [opcjonalnie] dla elementów będących tablicami określa indeks komórki, której wartość będzie ustawiana. Jeżeli parametr pominiemy lub podamy jako Default, domyślny indeks początkowy wyniesie 1, a następnie ustawionych zostanie tyle komórek, ile jest podanych wartości, np.: DllStructSetData($st, tab, 'AutoIt', Default). Jest to przydatne do szybkiego ustawiania stringów. Parametr nie jest używany dla elementów nie będących tablicami.
Wartość zwracana:
Sukces: wartość, która jest ponownie odczytywana ze struktury (makro @error = 0)
Błąd: 0 (makro @error ustawione na:)
1 – nieprawidłowa struktura
2 – element po za zakresem
3 – indeks po za zakresem
4 – nieznany typ danych
5 – indeks <=0
Uwagi:
Kiedy element jest typu char [n], byte [n] lub ubyte [n] dane mogą być stringiem, w przeciwnym razie muszą być liczbą.
Przykład:
$struct1=DllStructCreate("int; char[16]; ptr; byte")
$struct2=DllStructCreate("int n; char s_1[16]; ptr p1; byte l")
;nadanie wartości przez numer elementu
DllStructSetData($struct1,1,666)
;nadanie wartości przez nazwę
DllStructSetData($struct2,"s_1","AutoIt")
DllStructGetData
[edytuj]Zwraca wartość elementu struktury.
DllStructGetData (struktura, element [, indeks])
Parametry:
struktura - struktura danych zwrócona przez DllStructCreate.
element - do którego elementu struktury chcemy uzyskać dostęp (numeracja rozpoczyna się od 1), lub nazwa elementu ustalona w DllStructCreate.
indeks - [opcjonalnie] dla elementów, które są tablicami wartość ta określa indeks komórki do pobrania wartości. Jeżeli parametr pominiemy lub podamy jako Default, wtedy cała tablica zostanie pobrana (przydatna do szybkiego pobierania napisów). Parametr nie jest używany dla elementów nie będących tablicami.
Char [n], byte [n] i ubyte [n] zwróci wszystkie dane elementu, gdy indeks zostanie pominięty.
Wartość zwracana:
Sukces: wartość elementu struktury (@error = 0)
Błąd: 0 (makro @error ustawione na:)
1 – nieprawidłowa struktura
2 – element po za zakresem
3 – indeks po za zakresem
4 – nieznany typ danych
5 – indeks <=0
Uwagi:
Kiedy element jest char [n] oraz indeks zostanie pominięty dane zwracane są łańcuchem znaków, gdy element jest bajt [n] lub ubyte [n] oraz indeks zostanie pominięty, dane zwracane są typu binarny, w innych przypadkach zawsze zwracana jest liczba.
Przykład:
$struct=DllStructCreate("int n; char s_1[16]; ptr p1; byte l")
DllStructSetData($struct,1,666)
DllStructSetData($struct,"s_1","AutoIt")
MsgBox(0,"",DllStructGetData($struct,"n")&@LF&DllStructGetData($struct,2))
DllStructGetPtr
[edytuj]Zwraca wskaźnik do struktury danych lub do jej elementu.
DllStructGetPtr ( struktura [,element] )
Parametry:
struktura - struktura danych zwrócona przez DllStructCreate.
element - [opcjonalnie] element struktury, dla którego zostanie zwrócony wskaźnik (numer lub nazwa utworzona w DllStructCreate).
Wartość zwracana:
Sukces: wskaźnik do struktury lub jej elementu (@error = 0).
Błąd: 0 (makro @error ustawione na:)
1 – nieprawidłowa struktura
2 – elementu po za zakresem
Uwagi: Używany w DllCall.
Przykład:
$struct=DllStructCreate("int; char[16]; ptr; byte")
MsgBox(0,"",DllStructGetPtr($struct))
DllStructGetSize
[edytuj]Zwraca rozmiar struktury w bajtach.
DllStructGetSize (struktura)
Parametry:
struktura - struktura zwrócona przez DllStructCreate.
Wartość zwracana:
Sukces: rozmiar struktury w bajtach (@error = 0).
Błąd: 0 (makro @error ustawione na:)
1 – nieprawidłowa struktura
Przykład:
$struct=DllStructCreate("int; char[16]; ptr; byte")
MsgBox(0,"",DllStructGetPtr($struct))
IsDllStruct
[edytuj]Sprawdza czy zmienna zawiera strukturą.
IsDllStruct ( zmienna )
Paranetry:
zmienna - nazwa sprawdzanej zmiennej Funkcja zwraca 1 gdy wartość zmiennej jest strukturą, w przeciwnym przypadku zwraca 0.
Przykład:
$struct=DllStructCreate("int; char[16]; ptr; byte")
MsgBox(0,"",IsDllStruct($struct)) ;to jest struktura wyświetli 1
$a="AutoIt"
MsgBox(0,"",IsDllStruct($a)) ;to nie jest struktura wyświetli 0
Uproszczony sposób nadawania i odczytu wartości pól struktury
[edytuj]Od wersji AutoIt 3.3.10.2 wprowadzono uproszczony sposób nadawania i odczytu wartości pól struktury. Zamiast wywołań funkcji DllStructSetData i DllStructGetData można użyć zapisu wg poniższego schematu:
- nadanie wartości polu struktury:
$nazwa_struktury.nazwa_pola = wartość_pola
- nadanie wartości elementowi pola struktury (jeżeli pole jest tablicą):
$nazwa_struktury.nazwa_pola(numer_elementu) = wartość_elementu
- odczyt wartości pola struktury
$nazwa_zmiennej = $nazwa_struktury.nazwa_pola
- odczyt wartości elementu pola struktury (jeżeli pole jest tablicą):
$nazwa_zmiennej = $nazwa_struktury.nazwa_pola(numer_elementu)
Powyższy sposób może być użyty tylko do struktur utworzonych z nazwami pól.
Przykład:
$tStruct=DllStructCreate("int numer; char tekst[16]")
;nadawanie wartości polom struktury
$tStruct.numer = 666
$tStruct.tekst = "Wasta"
;odczyt wartości pól struktury
MsgBox(0, "$tStruct.numer", $tStruct.numer)
MsgBox(0, "$tStruct.tekst", $tStruct.tekst)
;odczyt wartości elementu pola będącego tablicą
MsgBox(0, "$tStruct.tekst(1)", $tStruct.tekst(1))
;zmiana wartości elementu pola struktury
$tStruct.tekst(3) = "r"
MsgBox(0, "$tStruct.tekst", $tStruct.tekst)
Co to jest Callback?
[edytuj]Wywołania zwrotne (ang. callback) - technika programowania będąca odwrotnością wywołania funkcji. Zwykle korzystanie z biblioteki polega na wywołaniu dostarczonych przez nią funkcji.
W tym przypadku jest odwrotnie: użytkownik jedynie rejestruje funkcję do późniejszego wykorzystania, natomiast funkcje biblioteczne wywołają ją w stosownym dla siebie czasie.
Najważniejszymi pojęciami są rejestracja oraz wywołanie zwrotne.
Rejestracja polega na zdefiniowaniu funkcji, która ma być wywołana zwrotnie przez funkcję biblioteczną.
Kiedy następuje wywołanie zwrotne, funkcja, która je wykonuje, nie wie nic o tym, co się zdarzy. Jest to zależne od tego, co zostało zarejestrowane do wywołania.
DllCallbackRegister
[edytuj]Tworzenie (rejestrowanie) zdefiniowanej przez użytkownika funkcji Callback DLL.
DllCallbackRegister ("funkcja", "typ_zwracany", "parametry")
Parametry:
funkcja - nazwa zdefiniowanej przez użytkownika funkcji do wywołania zwrotnego.
typ_zwracany - typ zwracanej wartości (patrz DllCall).
parametry - lista rozdzielonych średnikami parametrów przekazywanych do funkcji. Patrz uwagi.
Wartość zwracana:
Sukces: uchwyt do rejestrowanej funkcji, wykorzystywany przez DllCallbackGetPtr i DllCallbackFree.
Błąd: 0
Uwagi: Używa wszystkich typów danych DllCall, z wyjątkiem "struct".
Po zakończeniu pracy z callback, należy wywołać funkcję DllCallbackFree. Autoita wprawdzie zwalnia wszystkie uchwyty po zakończeniu działania skryptu, ale lepiej jest jawnie wyrejestrować funkcję wywołując DllCallbackFree.
DllCallbackGetPtr
[edytuj]Zwraca wskaźnik do funkcji callback, który może być przekazany do API Win32.
DllCallbackGetPtr (uchwyt)
Parametry:
uchwyt - uchwyt do DllCallback zwracany przez DllCallbackRegister.
Wartość zwracana:
Sukces: wskaźnik do funkcji zwrotnej (callback).
Błąd: 0
Uwagi: Użyj DllCallbackGetPtr dla przekazania adresu funkcji zwrotnej do Win32 API przy użyciu DllCall.
DllCallbackFree
[edytuj]Uwalnia uchwyt utworzony przez DllCallbackRegister.
DllCallbackFree (uchwyt)
Parametry:
uchwyt - uchwyt do DllCallback, zwracany przez DllCallbackRegister.
Funkcja nie zwraca żadnej wartości.
Uwagi: Autoita wprawdzie zwalnia wszystkie uchwyty po zakończeniu działania skryptu, ale lepiej jest jawnie wyrejestrować funkcję wywołując DllCallbackFree.
Kilka przykładów użycia systemowych bibliotek DLL
[edytuj]Sprawdzenie czy podany znak jest literą
[edytuj]Potrzebną funkcję odnajdujemy w bibliotece "user32.dll". W dokumentacji na stronie "MSDN Functions by Category" odnajdujemy opis funkcji wraz ze składnią wywołania. Wygląda ona tak:
BOOL WINAPI IsCharAlpha ( __in TCHAR ch );
Mamy więc:
Nazwa funkcji: IsCharAlpha
Typ wartości zwracanej: BOOL - 1 jeżeli tak / 0 jeżeli nie
Typ wartości parametru: TCHAR - parametrem jest sprawdzany znak
Jest jedna trudność, w DllCall nie ma typu TCHR! Rozwiązanie jest proste, zamiast TCHR użyjemy także jedno bajtowego typy "byte", a znak zamienimy na jego kod ASCII.
A teraz kod wywołujący funkcję DLL:
$chr="a"
$tab=DllCall("user32.dll","bool","IsCharAlpha","byte",Asc($chr))
MsgBox(0,"",$tab[0]) ;wyświetli 1
$chr="@"
$tab=DllCall("user32.dll","bool","IsCharAlpha","byte",Asc($chr))
MsgBox(0,"",$tab[0]) ;wyświetli 0
Zamiana liter w stringu na duże
[edytuj]DLL: user32.dll
Składnia:
LPSTR WINAPI CharUpper ( __inout LPTSTR lpsz );
Nazwa funkcji: CharUpper
Typ wartości zwracanej: LPSTR - string wynikowy
Typ wartości parametru: LPSTR - przetwarzany string
Kod:
$str="janek ma łąkę"
$tab=DllCall("user32.dll","str","CharUpper","str",$str)
MsgBox(0,"",$tab[0])
Odczyt danych z zegara systemowego
[edytuj]DLL: kernel32.dll
Składnia:
void WINAPI GetSystemTime (
__out LPSYSTEMTIME lpSystemTime
);
gdzie:
typedef struct {_SYSTEMTIME
WYear WORD;
WORD wMonth;
WDayOfWeek WORD;
WORD wDay;
WHour WORD;
WORD wMinute;
WSecond WORD;
WMilliseconds WORD;
} SYSTEMTIME, * PSYSTEMTIME;
Jak widać parametrem funkcji GetSystemTime jest struktura typu out (funkcja będzie do niej zapisywać wynik swojego działania, więc nie musimy nadawać wartości elementom).
Struktura ma 8 elementów wszystkie typu WORD.
Mamy już wszystkie dane do stworzenia kodu (udostępnienie struktury przez wskaźnik):
$struct=DllStructCreate("word;word;word;word;word;word;word;word")
DllCall("kernel32.dll","none","GetSystemTime","ptr",DllStructGetPtr($struct))
$y=DllStructGetData($struct,1)
$m=DllStructGetData($struct,2)
$d=DllStructGetData($struct,4)
MsgBox(0,"Data:",$y&"-"&$m&"-"&$d)
Można też tak, udostępniając strukturę przez referencję:
$struct=DllStructCreate("word;word;word;word;word;word;word;word")
DllCall("kernel32.dll","none","GetSystemTime","struct*",$struct)
$y=DllStructGetData($struct,1)
$m=DllStructGetData($struct,2)
$d=DllStructGetData($struct,4)
MsgBox(0,"Data:",$y&"-"&$m&"-"&$d)
Użycie funkcji typu CallBack
[edytuj]Napiszmy skrypt wyświetlający ilość i nazwy wszystkich otwartych okien.
W bibliotece "user32.dll" jest funkcja EnumWindows. Wylicza ona wszystkie istniejące okna. Jej składnia to:
BOOL WINAPI EnumWindows ( __in WNDENUMPROC lpEnumFunc, __in LPARAM lParam );
Funkcja ta przyjmuje 2 parametry:
WNDENUMPROC - który jest wskaźnikiem do funkcji zwrotnej
LPARAM - to dodatkowa wartość przekazywana do funkcji zwrotnej
Ponadto EnumWindows przekazuje do funkcji zwrotnej uchwyt do aktualnie wyliczanego okna.
Jeżeli funkcja zwrotna zwraca wartość True to wyliczanie jest kontynuowane (aż do wyczerpania wszystkich okien), wartość False kończy działanie funkcji EnumWindows.
Nasz skrypt może wyglądać tak:
Global $count=0, $countname=""
$handle = DllCallbackRegister("_CountWin","none","hwnd") ;rejestrowanie funkcji zwrotnej
DllCall("user32.dll", "BOOL", "EnumWindows", "ptr", DllCallbackGetPtr($handle), "lparam", 0)
DllCallbackFree($handle)
MsgBox(0,"Ilość i nazwy okien:","Ilość okien = "&$count&@LF&$countname)
;definicja funkcji zwrotnej
;wyliczanie ograniczamy do okien otwartych i posiadających nazwę
Func _CountWin($hWnd)
If WinGetTitle($hWnd) <> "" And BitAND(WinGetState($hWnd), 2) Then
$count+=1
$countname&=@LF&WinGetTitle($hWnd)
EndIf
Return 1 ;zwracamy True aby kontynuować wyliczanie, aż do wyczerpania okien
EndFunc
Ćwiczenia
[edytuj]1. W oparciu o funkcję GUICtrlCreateInput napisać funkcję umożliwiającą wprowadzanie stringów określonego typu, np.:liczby rzeczywiste i całkowite, szesnastkowe, ósemkowe, dwójkowe, itp.
Ponadto używając funkcji systemowych wywoływanych przez DllCall(), umożliwić nawigację między polami INPUT klawiszami ENTER oraz strzałka w górę i w dół.
Stworzoną funkcję użyj w prostym skrypcie demonstracyjnym.
Przykładowe rozwiązania: AutoIt/Ćwiczenia dla zaawansowanych - przykładowe rozwiązania