AutoIt/WinAPI
Co to jest WinAPI
edytujWg Wiki:
Windows API, lub krócej: WinAPI – interfejs programistyczny systemu Microsoft Windows – jest to zbiór niezbędnych funkcji, stałych i zmiennych umożliwiających działanie programu w systemie operacyjnym Microsoft Windows.
Zbiór ten jest bardzo obszerny i zawiera funkcje do tworzenia okien programów, elementów interfejsu graficznego, obsługi zdarzeń oraz umożliwiające dostęp do innych aplikacji, funkcji sieciowych czy sprzętu w komputerze.
Mianem WinAPI określamy standardowe funkcje przychodzące wraz z plikami bibliotek DLL dostarczanymi z systemem, np. kernel32.dll, user32.dll, gdi32.dll, wsock32.dll, znajdującymi się w katalogu \Windows\System.
Funkcje korzystające z WinAPI zawarte są w UDF'ie WinAPI.au3. Jest to największy UDF, ale część zawartych w nim funkcji dubluje funkcje wbudowane interpretera lub innych UDF'ów np.: GDIPlus.au3.
W niniejszym opisie skupię się więc na funkcjach udostępniających nowe możliwości.
Struktury (rekordy)
edytujNiektóre funkcje znajdujące się w UDF'ie wykorzystują struktury jako parametry wywołania lub używają ich do zwracania wyników.
Tworzenie takich struktur ułatwia plik StructureConstants.au3, który zawiera predefiniowane stringi z opisem budowy typowych struktur. Nie musimy dołączać go dyrektywą #include, gdyż robi to już sam UDF.
Poniżej przykład tworzenia struktury zawierającej dane o wielkości i położeniu prostokątnego obszaru:
;tworzenie struktury na podstawie stringu $tagRECT
;z biblioteki StructureConstants.au3
$tRect = DllStructCreate($tagRECT)
;nadanie wartości poszczególnym polom struktury
DllStructSetData($tRect, "Left", 20)
DllStructSetData($tRect, "Top", 50)
DllStructSetData($tRect, "Right", 200)
DllStructSetData($tRect, "Bottom", 200)
;jeżeli zamiast samej struktury potrzebny jest wskaźnik do niej
;należy dodatkowo użyć funkcji odczytującej ten wskaźnik
$ptrRect = DllStructGetPtr($tRect)
;dalsza część progamu
Można też tak, wykorzystując skrócony sposób nadawania wartości pól struktury:
;tworzenie struktury na podstawie stringu $tagRECT
;z biblioteki StructureConstants.au3
$tRect = DllStructCreate($tagRECT)
;nadanie wartości poszczególnym polom struktury (sposób uproszczony)
$tRect.Left = 20
$tRect.Top = 50
$tRect.Right = 200
$tRect.Bottom = 200
;dalsza część progamu
Dokładniejszy opis dotyczący struktur i funkcji na nich operujących, w rozdziale Korzystanie z bibliotek DLL.
_WinAPI_PtInRect
edytuj#include <WinAPI.au3> _WinAPI_PtInRect($tRect, $tPoint)
Funkcja zwraca True gdy punkt znajduje się wewnątrz prostokątnego obszaru, lub False w przeciwnym przypadku.
$tRect - struktura $tagRECT zawierająca dane o położeniu i wielkości prostokątnego obszaru
$tPoint - struktura $tagPOINT zawierająca współrzędne sprawdzanego punktu
Przykład:
#include <WinAPI.au3>
;opis prostokąta
$tRect = DllStructCreate($tagRECT)
$tRect.Left = 20
$tRect.Top = 50
$tRect.Right = 200
$tRect.Bottom = 200
;współrzędne sprawdzanego punktu
$tPoint = DllStructCreate($tagPOINT)
$tPoint.X = 120
$tPoint.Y = 120
If _WinAPI_PtInRect($tRect, $tPoint) Then
$sTxt = "Punkt wewnątrz prostokąta"
Else
$sTxt = "Punkt na zewewnątrz prostokąta"
EndIf
MsgBox(4096, 'Test PtInRect', $sTxt)
_WinAPI_RectIsEmpty
edytuj#include <WinAPI.au3> _WinAPI_RectIsEmpty($tRect)
Funkcja zwraca True gdy struktura opisująca prostokąt zawiera same zera, lub False w przeciwnym przypadku.
$tRect - struktura $tagRECT zawierająca dane o położeniu i wielkości prostokątnego obszaru
Przykład:
#include <WinAPI.au3>
;opis prostokąta
$tRect = DllStructCreate($tagRECT)
DllStructSetData($tRect, "Left", 0)
DllStructSetData($tRect, "Top", 0)
DllStructSetData($tRect, "Right", 0)
DllStructSetData($tRect, "Bottom", 0)
MsgBox(4096, 'RectIsEmpty', _
"Czy prostokąt jest pusty: " & _WinAPI_RectIsEmpty($tRect))
_WinAPI_PointFromRect
edytuj#include <WinAPI.au3> _WinAPI_PointFromRect($tRect [, $fCenter = True])
Funkcja zwraca w postaci struktury $tagPOINT współrzędne środka, lub lewego górnego narożnika prostokątnego obszaru.
$tRect - struktura $tagRECT zawierająca dane o położeniu i wielkości prostokątnego obszaru
$fCenter - jeśli True zwraca punkt środkowy tego prostokąta, jeśli False jego współrzędne lewego górnego narożniku
Przykład:
#include <WinAPI.au3>
;opis prostokąta
$tRect = DllStructCreate($tagRECT)
DllStructSetData($tRect, "Left", 20)
DllStructSetData($tRect, "Top", 50)
DllStructSetData($tRect, "Right", 200)
DllStructSetData($tRect, "Bottom", 200)
$tPoint = _WinAPI_PointFromRect($tRect)
$iX = DllStructGetData($tPoint, 1)
$iY = DllStructGetData($tPoint, 2)
MsgBox(4096, "PointFromRect", _
"Punkt środkowy prostokąta:" & @LF & _
"x = " & $iX & @LF & "y = " & $iY)
_WinAPI_GetXYFromPoint
edytuj#include <WinAPI.au3> _WinAPI_GetXYFromPoint($tPoint, ByRef $iX, ByRef $iY)
Funkcja zwraca przez referencję współrzędne punktu.
$tPoint - struktura $tagPOINT zawierająca współrzędne punktu
$iX i $iY - zmienne zawierające współrzędne punktu (nadpisywane przez referencję)
Przykład:
#include <WinAPI.au3>
Local $iX = 10, $iY = 10
;opis prostokąta
$tPoint = DllStructCreate($tagPOINT)
DllStructSetData($tPoint, "X", 100)
DllStructSetData($tPoint, "Y", 666)
;odczyt współrzędnych (przez referencję)
_WinAPI_GetXYFromPoint($tPoint, $iX, $iY)
MsgBox(4096, "GetXYFromPoint", _
"Odczytane współrzędne punktu:" & @LF & _
"x = " & $iX & @LF & "y = " & $iY)
Funkcje związane z kontekstem urządzenia (DC)
edytujWszystkie funkcje graficzne WinAPI operują na kontekstach urządzeń. Podstawowe informacje o kontekstach można znaleźć w rozdziale Funkcje interfejsu GDI+.
Teraz postaram się opisać temat nieco dokładniej, gdyż UDF dostarcza dużej ilości funkcji operujących na kontekstach i głębsze zrozumienie problemu będzie bardzo pomoncne w ich efektywnym wykorzystaniu.
Twórcy Windows postanowili uprościć i ujednolicić operacje graficzne w systemie operacyjnym. Zamiast całej masy przypadków przesyłania informacji pomiędzy obiektami graficznymi (np. desktop -> okno, okno -> okno, okno -> bitmapa ... itd.) postanowili sprowadzić wszystko do jednego schematu:
[Kontekst źródłowy] -> [Kontekst docelowy]
Konteksty to jednak abstrakcje, same w sobie nie reprezentujące żadnego rzeczywistego obiektu. Dlatego kontekst musi być powiązany z rzeczywistym obiektem. Powiązanie to oznacza, że operacje wykonywane na kontekście będą jednocześnie wykonywane w tle na rzeczywistym obiekcie, bez konieczności zagłębiania się przez programistę w sam przebieg tego procesu. Wymiana informacji między kontekstami przebiega zawsze w ten sam sposób, natomiast przepływ informacji
[obiekt] <-> [kontekst] jest realizowany przez OS bez udziału programisty:
[Obiekt źródłowy]-[Kontekst źródłowy] -> [Kontekst docelowy]-[Obiekt docelowy]
Oczywiście aby cały proces był możliwy do realizacji, konteksty i obiekty muszą być ze sobą zgodne (kompatybilne), tzn. zdolne do wymiany informacji.
Rozpatrzmy dwa przykłady:
1. Skopiowanie fragmentu desktopu do utworzonego okna GUI:
Mamy do czynienia z dwoma istniejącymi obiektami, które są ze sobą z natury kompatybilne (wszak okno to nic innego jak część desktopu).
Należy więc pobrać z systemu konteksty do obu obiektów (funkcja _WinAPI_GetDC), a następnie przesłać dane z kontekstu desktopu do kontekstu okna.
Prosto i bez wnikania w szczegóły procesu.
Przykładowy kod dla tego przypadku w opisie funkcji _WinAPI_BitBlt.
2. Skopiowanie fragmentu desktopu do bitmapy:
W tym przypadku istnieje tylko jeden obiekt (desktop), drugi obiekt (bitmapa) należy samodzielnie utworzyć.
Rozpoczynamy od pobrania kontekstu do desktopu (_WinAPI_GetDC), następnie tworzymy nowy kontekst kompatybilny z kontekstem desktopu (_WinAPI_CreateCompatibleDC).
Teraz tworzymy bitmapę kompatybilną z utworzonym kontekstem (_WinAPI_CreateCompatibleBitmap) i tworzymy powiązania pomiędzy kontekstem i bitmapą (_WinAPI_SelectObject).
Mamy teraz powiązanie między desktopem, a bitmapą (poprzez kompatybilne konteksty) i możemy przesłać dane obrazu.
Przykładowy kod dla tego przypadku w opisie funkcji _WinAPI_CreateCompatibleBitmap.
_WinAPI_GetDC
edytuj#include <WinAPI.au3> _WinAPI_GetDC($hWnd)
Funkcja odczytuje i zwraca kontekst do obszaru roboczego okna, lub 0 gdy wystąpił błąd.
$hWnd - uchwyt do okna
Zwolnienie kontekstu za pomocą funkcji #_WinAPI_ReleaseDC.
Przykład:
#Include <WinAPI.au3>
$hWnd = GUICreate ("Test")
$hDC = _WinAPI_GetDC($hWnd)
MsgBox (0, "", "Uchwyt DC: " & $hDC)
_WinAPI_ReleaseDC ($hWnd, $hDC)
_WinAPI_GetWindowDC
edytuj#include <WinAPI.au3> _WinAPI_GetWindowDC($hWnd)
Funkcja odczytuje i zwraca kontekst do całego okna, lub 0 gdy wystąpił błąd.
$hWnd - uchwyt do okna, jeżeli wstawimy 0 to będzie to oznaczało cały ekran (desktop).
Zwolnienie kontekstu za pomocą funkcji _WinAPI_ReleaseDC .
Przykład:
#Include <WinAPI.au3>
$hWnd = GUICreate ("Test")
$hDC = _WinAPI_GetWindowDC($hWnd)
MsgBox (0, "", "Uchwyt DC: " & $hDC)
_WinAPI_ReleaseDC ($hWnd, $hDC)
_WinAPI_CreateCompatibleDC
edytuj#include <WinAPI.au3> _WinAPI_CreateCompatibleDC($hDC)
Funkcja tworzy kontekst zgodny z istniejącym kontekstem urządzenia. Zwraca uchwyt do tego kontekstu, lub 0 gdy wystąpił błąd.
$hDC - uchwyt do istniejącego kontekstu DC
Likwidacja kontekstu za pomocą funkcji _WinAPI_DeleteDC .
_WinAPI_DeleteDC
edytuj#include <WinAPI.au3> _WinAPI_DeleteDC($hDC)
Funkcja likwiduje kontekst. Zwraca True gdy sukces, lub False gdy wystąpił błąd.
$hDC - uchwyt do kontekstu DC
Funkcji należy używać do usunięcia kontekstów utworzonych w skrypcie (_WinAPI_CreateCompatibleDC), a już nie wykorzystywanych, celem zwolnienia zasobów.
_WinAPI_ReleaseDC
edytuj#include <WinAPI.au3> _WinAPI_ReleaseDC($hWnd, $hDC)
Funkcja zwalnia wcześniej pobrany kontekst. Zwraca True gdy sukces, lub False gdy wystąpił błąd.
$hWnd - uchwyt do okna
$hDC - uchwyt do kontekstu DC
Funkcji należy używać do zwolnienia kontekstów pobranych w skrypcie (_WinAPI_GetDC lub _WinAPI_GetWindowDC), a już nie wykorzystywanych, celem zwolnienia zasobów.
_WinAPI_SelectObject
edytuj#include <WinAPI.au3> _WinAPI_SelectObject($hDC, $hGDIObj)
Funkcja przypisuje obiekt do określonego kontekstu urządzenia. Zwraca uchwyt do pierwotnego obiektu (tego który był poprzednio przypisany do kontekstu), lub liczbę ujemną gdy wystąpił błąd.
Obiekt musi być jednego z następujących typów: Bitmap, Brush, Font, Pen lub Region.
$hDC - uchwyt do kontekstu DC
$hGDIObj - uchwyt do przypisywanego obiektu
Przykład:
#include <WindowsConstants.au3>
#include <WinAPI.au3>
;odczytanie kontekstu do desktopu
$hDC = _WinAPI_GetWindowDC(0)
;tworzenie piór
$hPen1 = _WinAPI_CreatePen($PS_SOLID, 12, 0x0000FF)
$hPen2 = _WinAPI_CreatePen($PS_SOLID, 20, 0x00FF00)
;przypisanie pióra 1 do kontekstu
_WinAPI_SelectObject($hDC, $hPen1)
;rysowanie linni w kontekście
_WinAPI_DrawLine($hDC, 400, 500, 800, 700)
;przypisanie pióra 2 do kontekstu
$hOld = _WinAPI_SelectObject($hDC, $hPen2)
;rysowanie linni w kontekście
_WinAPI_DrawLine($hDC, 400, 700, 800, 400)
Sleep(5000)
;jeżeli chcemy wrócić do poprzedniego przypisania
_WinAPI_SelectObject($hDC, $hOld)
;zwolnienie zasobów
_WinAPI_DeleteObject($hPen1)
_WinAPI_DeleteObject($hPen2)
_WinAPI_ReleaseDC(0, $hDC)
_WinAPI_DeleteObject
edytuj#include <WinAPI.au3> _WinAPI_DeleteObject ( $hObject )
Funkcja usuwa logiczne, obiekty takie jak pióro, pędzel, czcionka, bitmapa, region lub paleta. Zwraca True gdy sukces, lub False gdy wystąpił błąd.
$hObject - uchwyt do usuwanego obiektu
_WinAPI_BitBlt
edytuj#include <WinAPI.au3> _WinAPI_BitBlt($hDestDC, $iXDest, $iYDest, $iWidth, $iHeight, $hSrcDC, $iXSrc, $iYSrc, $iROP)
Funkcja kopiuje blok grafiki pomiędzy dwoma kontekstami urządzeń. Zwraca True gdy sukces, lub False gdy wystąpił błąd.
$hDestDC - uchwyt do kontekstu docelowego
$iXDest i $iYDest - współrzędne lewego górnego narożnika wstawianego bloku w kontekście docelowym
$iWidth i $iHeight - szerokość i wysokość kopiowanego bloku
$hSrcDC - uchwyt do kontekstu źródłowego
$iXSrc i $iYSrc - współrzędne lewego górnego narożnika kopiowanego bloku w kontekście źródłowym
$iROP - kod operacji. Kody te określają, w jaki sposób dane kolorowego prostokątnego bloku kopiowanego z kontekstu źródłowego zostaną połączone z kolorami znajdującymi się w prostokącie docelowym:
Nazwy stałych wg <WindowsConstants.au3>
---------------------------------------------------------------------------------------------------------
$BLACKNESS = 0x00000042 | Wypełnia prostokąt docelowy używając koloru związanego z indeksem 0
| w palecie fizycznej (ten kolor jest czarny dla domyślnej palety).
---------------------------------------------------------------------------------------------------------
$CAPTUREBLT = 0x40000000 | Zawiera wszystkie okna, które są nakładane na górze okna w obraz wynikowy.
---------------------------------------------------------------------------------------------------------
$DSTINVERT = 0x00550009 | Negatyw prostokąta docelowego.
---------------------------------------------------------------------------------------------------------
$MERGECOPY = 0x00C000CA | Łączy za pomocą operatora AND kolor prostokąta źródłowego z kolorem
| aktualnie wybranego w $hDestDC pędzla.
---------------------------------------------------------------------------------------------------------
$MERGEPAINT = 0x00BB0226 | Łączy za pomocą operatora OR negatyw prostokąta źródłowego
| z kolorami prostokąta docelowego.
---------------------------------------------------------------------------------------------------------
$NOMIRRORBITMAP = 0x80000000 |
---------------------------------------------------------------------------------------------------------
$NOTSRCCOPY = 0x00330008 | Kopiuje negatyw prostokąta źródłowego do miejsca przeznaczenia.
---------------------------------------------------------------------------------------------------------
$NOTSRCERASE = 0x001100A6 | Łączy za pomocą operatora OR kolory prostokąta źródłowego i docelowego,
| a następnie wykonuje negatyw powstałych kolorów.
---------------------------------------------------------------------------------------------------------
$PATCOPY = 0x00F00021 | Kopiuje pędzel aktualnie wybranego w $hDestDC, do bitmapy docelowej.
---------------------------------------------------------------------------------------------------------
$PATINVERT = 0x005A0049 | Łączy za pomocą operatora XOR kolor pędzla aktualnie wybranego w $hDestDC,
| z kolorami prostokąta docelowego.
---------------------------------------------------------------------------------------------------------
$PATPAINT = 0x00FB0A09 | Łączy za pomocą operatora OR, kolor pędzla aktualnie wybranego w $hDestDC,
| z negatywem prostokąta źródłowego. Wynik tej operacji jest połączony
| za pomocą operatora OR, z kolorami prostokąta docelowego.
---------------------------------------------------------------------------------------------------------
$SRCAND = 0x008800C6 | Łączy za pomocą operatora AND, kolory prostokąta źródłowego i docelowego.
---------------------------------------------------------------------------------------------------------
$SRCCOPY = 0x00CC0020 | Kopiuje prostokąt źródłowy bezpośrednio do prostokąta docelowego.
---------------------------------------------------------------------------------------------------------
$SRCERASE = 0x00440328 | Łączy za pomocą operatora AND, negatyw prostokąta docelowego
| z kolorami prostokąta źródłowego.
---------------------------------------------------------------------------------------------------------
$SRCINVERT = 0x00660046 | Łączy za pomocą operatora XOR, kolory prostokąta źródłowego i docelowego.
---------------------------------------------------------------------------------------------------------
$SRCPAINT = 0x00EE0086 | Łączy za pomocą operatora OR, kolory prostokąta źródłowego i docelowego.
---------------------------------------------------------------------------------------------------------
$WHITENESS = 0x00FF0062 | Wypełnia prostokąt docelowy używając koloru związanego z indeksem 1
| w palecie fizycznej (ten kolor jest biały dla domyślnej palety).
Przykład:
#include <GUIConstantsEx.au3>
#include <WindowsConstants.au3>
#include <WinAPI.au3>
#include <GDIPlus.au3>
#region tworzenie testowego obrazka
$hGUI = GUICreate("GDI+", 400, 450)
GUISetState()
_GDIPlus_Startup()
$hGraphic = _GDIPlus_GraphicsCreateFromHWND($hGUI)
;rysowanie elipsy domyślnym pędzlem
_GDIPlus_GraphicsfillEllipse($hGraphic, 160, 100, 150, 100)
$hBrush = _GDIPlus_BrushCreateSolid(0xB0FF0000) ;tworzenie pędzla
_GDIPlus_GraphicsFillEllipse($hGraphic, 210, 30, 120, 250, $hBrush)
Sleep(200) ;chwila na zakończenie tworzenia obrazka
;zwolnienie zasobów
_GDIPlus_BrushDispose($hBrush)
_GDIPlus_GraphicsDispose($hGraphic)
_GDIPlus_Shutdown()
#endregion tworzenie testowego obrazka
$hGUIDC = _WinAPI_GetDC($hGUI) ;kontekst do obszaru roboczego GUI
$hDC = _WinAPI_GetWindowDC(0) ;kontekst do desktopu
;kopiowanie fragmentów desktopu do GUI
_WinAPI_BitBlt($hGUIDC, 0, 0, 300, 200, $hDC, 0, 0, $SRCCOPY)
_WinAPI_BitBlt($hGUIDC, 100, 220, 250, 200, $hDC, 20, 0, $SRCAND)
Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE
;zwolnienie zasobów
_WinAPI_ReleaseDC (0, $hDC)
_WinAPI_ReleaseDC ($hGUI, $hGUIDC)
_WinAPI_SetTextColor
edytuj#include <WinAPI.au3> _WinAPI_SetTextColor($hDC, $iColor)
Funkcja ustawia kolor aktualnej czcionki w danym kontekście urządzenia. Zwraca kod poprzedniego koloru, lub -1 gdy wystąpił błąd.
$hDC - uchwyt do kontekstu
$iColor - kod koloru w formacie RGB
_WinAPI_SetBkColor
edytuj#include <WinAPI.au3> _WinAPI_SetBkColor($hDC, $iColor)
Funkcja ustawia kolor tła w danym kontekście urządzenia. Zwraca kod poprzedniego koloru, lub -1 gdy wystąpił błąd.
$hDC - uchwyt do kontekstu
$iColor - kod koloru w formacie RGB
_WinAPI_GetBkMode
edytuj#include <WinAPI.au3> _WinAPI_GetBkMode($hDC)
Funkcja zwraca tryb wyświetlania tła w danym kontekście urządzenia, lub 0 gdy wystąpił bład.
Zwracane wartości:
1 ($TRANSPARENT) - tło przezroczyste
2 ($OPAQUE) - tło nieprzezroczyste
$hDC - uchwyt do kontekstu
_WinAPI_SetBkMode
edytuj#include <WinAPI.au3> _WinAPI_SetBkMode($hDC, $iBkMode)
Funkcja ustawia tryb wyświetlania tła w danym kontekście urządzenia. Zwraca kod poprzedniego trybu, lub 0 gdy wystąpił błąd.
$hDC - uchwyt do kontekstu
$iBkMode - kod trybu wyświetlania tła:
1 ($TRANSPARENT) - tło przezroczyste
2 ($OPAQUE) - tło nieprzezroczyste
Przykład:
#include <FontConstants.au3>
#include <WinAPI.au3>
#include <WindowsConstants.au3>
Global $hDC, $hFont, $hFont_old, $iTextColor = 0xFF0000
HotKeySet("{ESC}", "_Exit") ;rejestrowanie funkcji zamykającej skrypt
;definiowanie prostokątnego obszaru, w którym będziemy wpisywali tekst
$tRECT = DllStructCreate($tagRect)
$tRECT.Left = 850
$tRECT.Top = 300
$tRECT.Right = 1250
$tRECT.Bottom = 550
$hDC = _WinAPI_GetDC(0) ;pobranie kontekstu do desktopu
$hFont = _WinAPI_CreateFont(50, 0, 0, 0, 400, False, False, False, $DEFAULT_CHARSET, _
$OUT_DEFAULT_PRECIS, $CLIP_DEFAULT_PRECIS, $DEFAULT_QUALITY, 0, 'Arial') ;definicja fontów
$hFont_old = _WinAPI_SelectObject($hDC, $hFont) ;zapamiętanie pierwotnych fontów i ustawienie nowych
_WinAPI_SetBkColor($hDC, 0x000000) ;definicja koloru tła
_WinAPI_SetBkMode($hDC, $TRANSPARENT) ;tło przezroczyste
Do
_WinAPI_SetTextColor($hDC, $iTextColor) ;ustawienie koloru tekstu
_WinAPI_DrawText($hDC, "AUTOIT jest super!", $tRECT, $DT_CENTER) ;wypisanie tekstu
Sleep(50)
Until False
;funkcja zwalniająca zasoby i zamykająca skrypt
Func _Exit()
_WinAPI_SelectObject($hDC, $hFont_old)
_WinAPI_DeleteObject($hFont)
_WinAPI_ReleaseDC(0, $hDC)
_WinAPI_InvalidateRect(0, 0)
$tRECT = 0
Exit
EndFunc
Funkcje związane z tworzeniem i przetwarzaniem grafiki
edytuj_WinAPI_CreateBitmap
edytuj#include <WinAPI.au3> _WinAPI_CreateBitmap($iWidth, $iHeight [, $iPlanes = 1 [, $iBitsPerPel = 1 [, $pBits = 0]]])
Funkcja tworzy bitmapę o określonej szerokości, wysokość, kolorze i formacie. Zwraca uchwyt do bitmapy, lub 0 gdy wystąpił błąd.
$iWidth - szerokość bitmapy w pikselach
$iHeight - wysokość bitmapy w pikselach
$iPlanes - określa liczbę płaszczyzn kolorów używanych przez urządzenia
$iBitsPerPel - liczba bitów potrzebnych do określenia barwy pojedynczego piksela
$pBits - wskaźnik do tablicy danych kolorów używanych do ustawienia kolorów pikseli. Jeżeli parametr ten ma wartość 0, zawartość nowej bitmapy jest niezdefiniowana.
_WinAPI_CreateCompatibleBitmap
edytuj#include <WinAPI.au3> _WinAPI_CreateCompatibleBitmap($hDC, $iWidth, $iHeight)
Funkcja tworzy bitmapę zgodną z określonym kontekstem urządzenia. Zwraca uchwyt do bitmapy, lub 0 gdy wystąpił błąd.
$hDC - uchwyt do kontekstu urządzenia
$iWidth - szerokość bitmapy w pikselach
$iHeight - wysokość bitmapy w pikselach
Przykład:
#include <WinAPI.au3>
#include <GDIPlus.au3>
Const $SRCCOPY = 0x00CC0020
Local $iX = 500, $iY = 300
_GDIPlus_Startup()
;pobranie kontekstu desktopu
$hDDC = _WinAPI_GetWindowDC(0)
;utworzenie kontekstu kompatybilnego do kontekstu desktopu
$hCDC = _WinAPI_CreateCompatibleDC($hDDC)
;utworzenie bitmapy kompatybilnej z kontekstem urządzenia
$hHBMP = _WinAPI_CreateCompatibleBitmap($hDDC, $iX, $iY)
;przypisanie bitmapy do kontekstu urządzenia
_WinAPI_SelectObject($hCDC, $hHBMP)
;kopiowanie danych obrazu między kontekstami
_WinAPI_BitBlt($hCDC, 0, 0, $iX, $iY, $hDDC, 30, 35, $SRCCOPY)
;tworzenie obiektu Bitmap z bitmapy
$hBitmap = _GDIPlus_BitmapCreateFromHBITMAP($hHBMP)
;zapis bitmapy na dysku
_GDIPlus_ImageSaveToFile($hBitmap, @ScriptDir & "\Test.jpg")
;zwolnienie zasobów
_GDIPlus_BitmapDispose($hBitmap)
_WinAPI_DeleteObject($hHBMP)
_WinAPI_DeleteDC($hCDC)
_GDIPlus_Shutdown()
;wyświetlenie utworzonego obrazka
SplashImageOn("Test", @ScriptDir & "\Test.jpg", $iX, $iY)
Sleep(5000)
_WinAPI_CreateSolidBitmap
edytuj#include <WinAPI.au3> _WinAPI_CreateSolidBitmap($hWnd, $iColor, $iWidth, $iHeight [, $bRGB = True])
Funkcja tworzy bitmapę typu solid (jednokolorową). Zwraca uchwyt do bitmapy, lub 0 gdy wystąpił błąd.
$hWnd - uchwyt do okna, w którym wyświetlona będzie bitmapa
$iColor - kolor bitmapy w formacie RGB
$iWidth - szerokość bitmapy w pikselach
$iHeight - wysokość bitmapy w pikselach
$bRGB - jeżeli True to $iColor łącznie z kanałem alfa (0x00RRGGBB)
Przykład:
#include <GUIConstantsEx.au3>
#include <WinAPI.au3>
#include <WindowsConstants.au3>
;tworzenie GUI
$hwnd = GUICreate("", 400, 300)
$Button = GUICtrlCreateButton("", 100, 30, 100, 100, 0x40)
$hDCDest = _WinAPI_GetDC($hwnd) ;kontekst do GUI
;tworzenie kompatybilnego kontekstu
$hDCSource = _WinAPI_CreateCompatibleDC($hDCDest)
;tworzenie bitmapy typu solid
$hHBitmap = _WinAPI_CreateSolidBitmap($hwnd, 0xff0000, 300, 300)
;przypisanie bitmapy do kompatybilnego kontekstu
_WinAPI_SelectObject($hDCSource, $hHBitmap)
GUISetState()
Do
$msg = GUIGetMsg()
;przeniesienie fragmentu bitmapy na przycisk
_WinAPI_BitBlt($hDCDest, 102, 32, 96, 96, $hDCSource, 0, 0, $SRCCOPY)
Until $msg = $GUI_EVENT_CLOSE Or $msg = $Button
;zwolnienie zasobów
_WinAPI_ReleaseDC($hwnd, $hDCDest)
_WinAPI_DeleteDC($hDCSource)
_WinAPI_DeleteObject($hHBitmap)
_WinAPI_CreatePen
edytuj#include <WinAPI.au3> _WinAPI_CreatePen($iPenStyle, $iWidth, $nColor)
Funkcja tworzy pióro (obiekt pen). Zwraca uchwyt do pióra, lub 0 gdy wystąpił błąd.
$iPenStyle - styl pióra:
PS_SOLID | linia ciągła PS_DASH | linia przerywana PS_DOT | linia punktowa PS_DASHDOT | na przemian kreska i kropka PS_DASHDOTDOT | na przemian kreska i dwie kropki PS_NULL | pióro jest niewidoczne PS_INSIDEFRAME | linia ciągła do wnętrza konturu zamkniętego
$iWidth - szerokość linii rysowanej przez pióro (w pikselach)
$nColor - kolor pióra w formacie BBGGRR (np. 0xAAF009)
Aby użyć pióra należy przypisać go do kontekstu urządzenia za pomocą funkcji _WinAPI_SelectObject.
Jeżeli wartość określona przez $nWidth jest większa niż 1, parametr $iPenStyle może być tylko PS_NULL, PS_SOLID lub PS_INSIDEFRAME.
Niepotrzebne już pióro należy usunąć funkcją _WinApi_DeleteObject celem zwolnienia zasobów.
Przykład:
#include <WindowsConstants.au3>
#include <WinAPI.au3>
$hDC = _WinAPI_GetWindowDC(0) ;kontekst do desktopu
;tworzenie pędzla
$hPen = _WinAPI_CreatePen($PS_SOLID, 12, 0x0000FF)
;przypisanie pędzla do kontekstu desktopu
$obj = _WinAPI_SelectObject($hDC, $hPen)
;rysowanie linii
_WinAPI_DrawLine($hDC, 400, 500, 900, 700)
;zmiana pędzla
$hPen = _WinAPI_CreatePen($PS_DASHDOTDOT, -1, -1)
$obj = _WinAPI_SelectObject($hDC, $hPen)
_WinAPI_DrawLine($hDC, 400, 800, 900, 500) ;
Sleep(2000)
;zwolnienie zasobów
_WinAPI_DeleteObject($hPen)
_WinAPI_ReleaseDC(0, $hDC)
_WinAPI_CreateSolidBrush
edytuj#include <WinAPI.au3> _WinAPI_CreateSolidBrush($nColor)
Funkcja tworzy pędzel (obiekt brush)typu solid. Zwraca uchwyt do pędzla, lub 0 gdy wystąpił błąd.
$nColor - kolor pędzla w formacie BBGGRR (np. 0xAAF009)
Niepotrzebny już pędzel należy usunąć funkcją _WinApi_DeleteObject celem zwolnienia zasobów.
Przykład:
#include <GUIConstantsEx.au3>
#include <WinAPI.au3>
$hGUI = GUICreate("WinAPI", 400, 300)
$hDC = _WinAPI_GetWindowDC($hGUI)
GUISetState()
;tworzenie pędzla
$hBrush = _WinAPI_CreateSolidBrush(0x0000FF)
;tworzenie struktury z danymi prostokąta
$tRect = DllStructCreate($tagRECT)
DllStructSetData($tRect, "Left", 20)
DllStructSetData($tRect, "Top", 50)
DllStructSetData($tRect, "Right", 200)
DllStructSetData($tRect, "Bottom", 200)
;odczyt wskaźnika do struktury
$ptrRect = DllStructGetPtr($tRect)
;rysowanie ramki wokół prostokąta
_WinAPI_FrameRect($hDC, $ptrRect, $hBrush)
Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE
;zwolnienie zasobów
_WinAPI_DeleteObject($hBrush)
_WinAPI_ReleaseDC($hGUI, $hDC)
_WinAPI_CreateFont
edytuj#include <WinAPI.au3>
_WinAPI_CreateFont($nHeight, $nWidth [, $nEscape = 0 [, $nOrientn = 0 [, $fnWeight = $FW_NORMAL
[, $bItalic = False [, $bUnderline = False [, $bStrikeout = False
[, $nCharset = $DEFAULT_CHARSET [, $nOutputPrec = $OUT_DEFAULT_PRECIS
[, $nClipPrec = $CLIP_DEFAULT_PRECIS [, $nQuality = $DEFAULT_QUALITY
[, $nPitch = 0 [, $szFace = 'Arial']]]]]]]]]]]])
Funkcja tworzy logiczną czcionkę o podanych cechach. Zwraca uchwyt do czcionki, lub 0 gdy wystąpił błąd.
$nHeight - wysokość czcionki
$nWidth - średnia szerokość czcionki
$nEscape - kąt pochylenia linii tekstu w dziesiętnych stopnia
$nOrientn -
$fnWeight - waga czcionki:
$FW_DONTCARE - 0 $FW_THIN - 100 $FW_EXTRALIGHT - 200 $FW_LIGHT - 300 $FW_NORMAL - 400 $FW_MEDIUM - 500 $FW_SEMIBOLD - 600 $FW_BOLD - 700 $FW_EXTRABOLD - 800 $FW_HEAVY - 900
$bItalic - italik True/False
$bUnderline - podkreślenie True/False
$bStrikeout - przekreślenie True/False
$nCharset - zestaw znaków, następujące wartości są predefiniowane:
$ANSI_CHARSET - 0 $BALTIC_CHARSET - 186 $CHINESEBIG5_CHARSET - 136 $DEFAULT_CHARSET - 1 $EASTEUROPE_CHARSET - 238 $GB2312_CHARSET - 134 $GREEK_CHARSET - 161 $HANGEUL_CHARSET - 129 $MAC_CHARSET - 77 $OEM_CHARSET - 255 $RUSSIAN_CHARSET - 204 $SHIFTJIS_CHARSET - 128 $SYMBOL_CHARSET - 2 $TURKISH_CHARSET - 162 $VIETNAMESE_CHARSET - 163
$nOutputPrec -
$nClipPrec -
$nQuality -
$nPitch -
$szFace - nazwa czcionki, np.: Arial, Arial Black, Courier, Courier New, Lucida Console, MS Sans Serif, Roman, Script, Times New Roman, itd.
Niepotrzebną już czcionkę należy usunąć funkcją _WinApi_DeleteObject celem zwolnienia zasobów.
_WinAPI_CreateFontIndirect
edytuj#include <WinAPI.au3> _WinAPI_CreateFontIndirect($tLogFont)
Funkcja tworzy logiczną czcionkę o podanych cechach. Zwraca uchwyt do czcionki, lub 0 gdy wystąpił błąd.
$tLogFont - struktura $tagLOGFONT , określająca cechy czcionki logicznej. Pola struktury:
Nazwa pola | Typ pola | Opis ------------------------------------------------------------------------------ Height | int | wysokość czcionki Width | int | średnia szerokość czcionki, 0 szerokość domyślna Escapement | int | kąt pochylenia linii tekstu w dziesiętnych stopnia Orientation | int | Weight | int | waga czcionki Italic | byte | czcionka pochylona - italik (True/False) Underline | byte | czcionka podkreślenie (True/False) StrikeOut | byte | czcionka przekreślenie (True/False) CharSet | byte | zestaw znaków OutPrecision | byte | ClipPrecision | byte | Quality | byte | PitchAndFamily | byte | FaceName | chr[32] | nazwa czcionki
Można używać predefiniowanych stałych, tak jak w _WinAPI_CreateFont.
Po wybraniu czcionki za pomocą SelectObject, GDI-font-Mapper próbuje dopasować czcionki logiczne do istniejącej czcionki fizycznej. Jeśli nie można znaleźć dokładne dopasowanie, zapewnia alternatywną czcionkę, której cechy są najbardziej zbieżne.
Niepotrzebny już czcinkę należy usunąć funkcją _WinApi_DeleteObject celem zwolnienia zasobów.
Przykład:
#include <WinAPI.au3>
#include <GUIConstants.au3>
#include <GuiListBox.au3>
#include <GuiButton.au3>
$hGUI = GUICreate("_WinAPI_CreateFontIndirect", 350, 200)
$hBtn = _GUICtrlButton_Create($hGUI, "Przycisk", 10, 10, 270, 34)
$hListBox = _GUICtrlListBox_Create($hGUI, "Dyski logiczne:", 10, 50, 270, 150)
_GUICtrlListBox_BeginUpdate($hListBox)
_GUICtrlListBox_Dir($hListBox, "", $DDL_DRIVES, False)
_GUICtrlListBox_EndUpdate($hListBox)
;tworzenie struktury
$tLogFont = DllStructCreate($tagLOGFONT)
DllStructSetData($tLogFont, "Height", 22)
DllStructSetData($tLogFont, "Weight", 700)
DllStructSetData($tLogFont, "Italic", True)
DllStructSetData($tLogFont, "FaceName", 'Arial')
;tworzenie czcionek
$hFont1 = _WinAPI_CreateFontIndirect($tLogFont)
DllStructSetData($tLogFont, "Italic", False)
DllStructSetData($tLogFont, "FaceName", 'Courier new')
$hFont2 = _WinAPI_CreateFontIndirect($tLogFont)
;ustawienie czcionek
_WinAPI_SetFont($hBtn, $hFont1)
_WinAPI_SetFont($hListBox, $hFont2)
GUISetState()
Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE
;zwolnienie zasobów
_WinAPI_DeleteObject($hFont1)
_WinAPI_DeleteObject($hFont2)
_WinAPI_GetStockObject
edytuj#include <WinAPI.au3> _WinAPI_GetStockObject($iObject)
Funkcja zwraca uchwyt do jednego z wbudowanych szablonów pióra, pędzla, czcionki lub palety. Jeżeli wystąpił błąd zwracane jest 0.
$iObject - wskazuje rodzaj obiektu. Parametr ten może być jedną z następujących wartości:
$BLACK_BRUSH - pędzel czarny $DKGRAY_BRUSH - pędzel ciemnoszary $GRAY_BRUSH - pędzel szary $HOLLOW_BRUSH - pędzel Null, to samo co $NULL_BRUSH $LTGRAY_BRUSH - pędzel jasnoszary $NULL_BRUSH - pędzel Null (niemalujący) $WHITE_BRUSH - pędzel biały $BLACK_PEN - pióro czarne $NULL_PEN - pióro Null $WHITE_PEN - pióro białe $ANSI_FIXED_FONT - czcionka systemowa nieproporcjonalna (o stałej szerokości) $ANSI_VAR_FONT - czcionka systemowa proporcjonalna (o zmiennej szerokości) $DEVICE_DEFAULT_FONT - czcionka domyślna zależna od urządzenia $DEFAULT_GUI_FONT - czcionka domyślna dla obiektów interfejsu użytkownika $OEM_FIXED_FONT - czcionka nieproporcjonalna OEM $SYSTEM_FONT - czcionka systemowa $SYSTEM_FIXED_FONT - czcionka systemowa nieproporcjonalna stosowana w systemach Windows wcześniejszych niż 3.0 $DEFAULT_PALETTE - paleta domyślna
Przykład:
#include <GUIConstantsEx.au3>
#include <WinAPI.au3>
$hGUI = GUICreate("GetStockObject", 400, 300)
$hDC = _WinAPI_GetWindowDC($hGUI)
GUISetState()
;ciemnoszary pędzel
$hBrush = _WinAPI_GetStockObject($DKGRAY_BRUSH)
$tRect = DllStructCreate($tagRECT)
DllStructSetData($tRect, "Left", 20)
DllStructSetData($tRect, "Top", 50)
DllStructSetData($tRect, "Right", 380)
DllStructSetData($tRect, "Bottom", 300)
$ptrRect = DllStructGetPtr($tRect)
_WinAPI_FillRect($hDC, $ptrRect, $hBrush)
Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE
;zwolnienie zasobów
_WinAPI_DeleteObject($hBrush)
_WinAPI_ReleaseDC($hGUI, $hDC)
_WinAPI_DrawText
edytuj#include <WinAPI.au3> _WinAPI_DrawText($hDC, $sText, ByRef $tRect, $iFlags)
Funkcja wstawia tekst do podanego kontekstu. Zwraca wysokość tekstu, lub 0 gdy wystąpił błąd.
$hDC - uchwyt do kontekstu
$sText - wstawiany tekst
$tRect - struktura $tagRECT, zawierająca współrzędne prostokąta, w którym będzie wstawiony tekst
$iFlags - flaga określająca jak ma być formatowany tekst:
$DT_BOTTOM - wyrównanie tekstu do dolnej krawędzi prostokąta
$DT_CALCRECT - oblicza szerokość i wysokość wymaganego prostokąta, wynik zwracany przez referencję w strukturze
$DT_CENTER - centrowanie tekstu poziomo w prostokącie
$DT_EDITCONTROL - jeżeli tekst jest wielowierszowy , to wiersz który nie mieści się w całości
na wysokości prostokąta nie będzie wyświetlany, ma sens tylko w parze
z $DT_WORDBREAK ($DT_WORDBREAK) + $DT_EDITCONTROL)
$DT_END_ELLIPSIS - zastępuje część tekstu wielokropkiem, jeżeli nie mieści się w prostokącie
$DT_EXPANDTABS - rozszerza znaki tabulacji, domyślny rozmiar tabulacji wynosi 8 znaków
$DT_EXTERNALLEADING -
$DT_HIDEPREFIX - nie jest wyświetlane podkreślenie znaku za prefiksem (&)
$DT_INTERNAL - używa trzcinki systemowej do wyliczenia wielkości tekstu
$DT_LEFT - wyrównanie tekstu do lewej
$DT_MODIFYSTRING -
$DT_NOCLIP - tekst nie jest przycinany gdy nie mieści się w prostokącie
$DT_NOFULLWIDTHCHARBREAK -
$DT_NOPREFIX - prefiks (&) jest wyświetlany jak zwykły znak
$DT_PATH_ELLIPSIS - jeżeli tekst nie mieści się w prostokącie, a zawiera odwrotny ukośnik (\),
część tekstu od ostatniego (\) w lewo jest zastąpiona wielokropkiem.
Ten styl jest używany do wyświetlania ścieżek do plików.
$DT_PREFIXONLY - wyświetla podkreślenie w miejscu znaku po prefiksie (&), inne znaki nie są wyświetlane
$DT_RIGHT - wyrównanie tekstu do prawej
$DT_RTLREADING - tekst od prawej do lewej, tylko dla czcionek arabskich i hebrajskich
$DT_SINGLELINE - tekst jest wyświetlany w jednym wierszu, część niemieszcząca się jest przycinana
$DT_TABSTOP -
$DT_TOP - wyrównanie tekstu do górnej krawędzi prostokąta (tylko tekst w jednej linii)
$DT_VCENTER - centrowanie tekstu w pionie (tylko tekst w jednej linii)
$DT_WORDBREAK - niemieszczący się wyrazy przenoszone są do następnego wiersza,
także znak końca wiersza powoduje jego złamanie, jeżeli $DT_WORDBREAK
nie jest użyte to tekst jest zawsze wyświetlany w jednym wierszu
$DT_WORD_ELLIPSIS - tnie dowolne słowo, które nie mieści się w prostokącie i dodaje wielokropek
Przykład:
#include <WinAPI.au3>
#include <WindowsConstants.au3>
#include <FontConstants.au3>
;tworzenie struktury
$tRECT = DllStructCreate($tagRect)
DllStructSetData($tRECT, "Left", 500)
DllStructSetData($tRECT, "Top", 250)
DllStructSetData($tRECT, "Right", 1100)
DllStructSetData($tRECT, "Bottom", 650)
;kontekst do desktopu
$hDC = _WinAPI_GetDC(0)
;tworzenie trzcionki logicznej
$hFont = _WinAPI_CreateFont(50, 0, 0, 0, 400, False, True, False, _
-1, -1, -1, -1, 0, 'Times New Roman')
;powiązanie czcionki z kontekstem
$hOldFont = _WinAPI_SelectObject($hDC, $hFont)
;wypisanie tekstu
_WinAPI_DrawText($hDC, "AutoIt is the best!", $tRECT, $DT_CENTER)
Sleep(3000)
;zwolnienie zasobów
_WinAPI_SelectObject($hDC, $hOldFont)
_WinAPI_DeleteObject($hFont)
_WinAPI_ReleaseDC(0, $hDC)
_WinAPI_InvalidateRect(0, 0)
_WinAPI_DrawLine
edytuj#include <WinAPI.au3> _WinAPI_DrawLine($hDC, $iX1, $iY1, $iX2, $iY2)
Funkcja rysuje w kontekście odcinek linii prostej. Zwraca True gdy sukces, lub False gdy wystąpił błąd.
$hDC - uchwyt do kontekstu
$iX1 i $iY1 - współrzędne, pozioma i pionowa początku odcinka
$iX2 i $iY2 - współrzędne, pozioma i pionowa końca odcinka
_WinAPI_LineTo
edytuj#include <WinAPI.au3> _WinAPI_LineTo($hDC, $iX, $iY)
Funkcja rysuje odcinek od bieżącego punktu do punktu o współrzędnych podanych jako parametry. Zwraca True gdy sukces, lub False gdy wystąpił błąd.
$hDC - uchwyt do kontekstu
$iX i $iY - współrzędne, pozioma i pionowa końca odcinka
_WinAPI_MoveTo
edytuj#include <WinAPI.au3> _WinAPI_MoveTo($hDC, $iX, $iY)
Funkcja przesuwa aktualną pozycję do określonego punktu. Zwraca True gdy sukces, lub False gdy wystąpił błąd.
$hDC - uchwyt do kontekstu
$iX i $iY - nowa współrzędne, pozioma i pionowa aktualnego pozycji
Przykład:
#include <WindowsConstants.au3>
#include <WinAPI.au3>
$hDC = _WinAPI_GetWindowDC(0) ;kontekst do pulpitu
;tworzenie pióra
$hPen = _WinAPI_CreatePen($PS_SOLID, 3, 0xFF)
;przypisanie pióra do kontekstu
$obj_orig = _WinAPI_SelectObject($hDC, $hPen)
_WinAPI_DrawLine($hDC, 400, 300, 1000, 250)
$del = 50
;przesunięcie punktu aktualnego
_WinAPI_MoveTo($hDC, 0, @DesktopHeight/2 - $del)
For $x = $del To @DesktopWidth Step 50
$y = @DesktopHeight/2 + $del
_WinAPI_LineTo($hDC, $x, $y) ;rysowanie linii
$del = -$del
Next
Sleep(4000)
;powrót do pierwotnego pióra
_WinAPI_SelectObject($hDC, $obj_orig)
;zwolnienie zasobów
_WinAPI_DeleteObject($hPen)
_WinAPI_ReleaseDC(0, $hDC)
_WinAPI_DrawEdge
edytuj#include <WinAPI.au3> _WinAPI_DrawEdge($hDC, $ptrRect, $nEdgeType, $grfFlags)
Funkcja rysuje krawędzie prostokąta. Zwraca True gdy sukces, lub False gdy wystąpił błąd.
$hDC - uchwyt do kontekstu kontekst
$ptrRect - wskaźnik do struktury $tagRECT z opisem położenie i wielkości prostokąta
$nEdgeType - określa rodzaj krawędzi
$BDR_RAISEDINNER - wypukła wewnętrzna krawędź $BDR_SUNKENINNER - wklęsła wewnętrzna krawędź $BDR_RAISEDOUTER - wypukła zewnętrzna krawędź $BDR_SUNKENOUTER - wklęsła zewnętrzna krawędź $EDGE_BUMP - kombinacja $BDR_RAISEDOUTER i $BDR_SUNKENINNER $EDGE_ETCHED - kombinacja $BDR_SUNKENOUTER i $BDR_RAISEDINNER $EDGE_RAISED - kombinacja $BDR_RAISEDOUTER i $BDR_RAISEDINNER $EDGE_SUNKEN - kombinacja $BDR_SUNKENOUTER i $BDR_SUNKENINNER
$grfFlags - określa rodzaj obramowania. Parametr ten może być kombinacją następujących wartości:
$BF_ADJUST - $BF_BOTTOM - dolna krawędź prostokąta $BF_BOTTOMLEFT - dolna i lewa krawędź prostokąta $BF_BOTTOMRIGHT - dolna i prawa krawędź prostokąta $BF_DIAGONAL - przekątna $BF_DIAGONAL_ENDBOTTOMLEFT - przekątna, od prawego-górnego do lewego-dolnego $BF_DIAGONAL_ENDBOTTOMRIGHT - przekątna, od lewego-górnego do prawego-dolnego $BF_DIAGONAL_ENDTOPLEFT - przekątna, od prawego-dolnego do lewego-górnego $BF_DIAGONAL_ENDTOPRIGHT - przekątna, od lewego-dolnego do prawego-górnego $BF_FLAT - obramowanie niewidoczne $BF_LEFT - lewa krawędź prostokąta $BF_MIDDLE - wnętrze prostokąta zamalowane (przekątne nie będą widoczne) $BF_MONO - obramowanie pojedynczą linią (wszystkie elementy jednakową) $BF_RECT - cały obwód od prostokąta $BF_RIGHT - prawa krawędź prostokąta $BF_SOFT - $BF_TOP - górna krawędź prostokąta $BF_TOPLEFT - górna i lewa krawędź prostokąta $BF_TOPRIGHT - górna i prawej krawędź prostokąta
Przykład:
#include <GUIConstantsEx.au3>
#include <WinAPI.au3>
#include <BorderConstants.au3>
;tworzenie GUI
$hGUI = GUICreate("_WinAPI_DrawEdge", 410, 300)
GUISetState()
;kontekst do przestrzeni roboczej okna
$hDC = _WinAPI_GetDC($hGUI)
;tworzenie struktury z opisem prostokąta
$tRect = DllStructCreate($tagRECT)
DllStructSetData($tRect, "Left", 20)
DllStructSetData($tRect, "Top", 50)
DllStructSetData($tRect, "Right", 200)
DllStructSetData($tRect, "Bottom", 200)
$ptrRect = DllStructGetPtr($tRect)
;rysowanie prostokąta
_WinAPI_DrawEdge($hDC, $ptrRect, $EDGE_RAISED , $BF_RECT)
;przesunięcie prostokąta poprzez zmianę wartości pól w strukturze
DllStructSetData($tRect, "Left", 220)
DllStructSetData($tRect, "Right", 400)
;rysowanie nowego prostokąta z przekątnymi
_WinAPI_DrawEdge($hDC, $ptrRect, $EDGE_BUMP, $BF_DIAGONAL_ENDBOTTOMLEFT)
_WinAPI_DrawEdge($hDC, $ptrRect, $EDGE_BUMP, $BF_DIAGONAL_ENDBOTTOMRIGHT)
_WinAPI_DrawEdge($hDC, $ptrRect, $EDGE_BUMP, $BF_RECT)
;zwolnienie zasobów
_WinAPI_ReleaseDC($hGUI, $hDC)
Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE
_WinAPI_DrawFrameControl
edytuj#include <WinAPI.au3> _WinAPI_DrawFrameControl($hDC, $ptrRect, $nType, $nState)
Funkcja rysuje elementy kontrolek określonego typu i stylu. Zwraca True gdy sukces, lub False gdy wystąpił błąd.
$hDC - uchwyt do kontekstu
$tRect - struktura $tagRECT, zawierająca współrzędne prostokąta, w którym będzie wrysowany element
$nType - typ rysowanego elementu. Parametr ten może być jedną z następujących wartości:
$DFC_BUTTON - standardowy przycisk $DFC_CAPTION - pasek tytułu $DFC_MENU - pasek menu $DFC_POPUPMENU - element menu podręcznego $DFC_SCROLL - pasek przewijania
$nState - określa początkowy stan ramki kontrolki:
------------------------------------------------------------------------------------ Jeśli $nType jest $DFC_BUTTON to $nState może być jedną z następujących wartości: ------------------------------------------------------------------------------------ $DFCS_BUTTON3STATE - przycisk 3-stanowy $DFCS_BUTTONCHECK - pole wyboru $DFCS_BUTTONPUSH - przycisk $DFCS_BUTTONRADIO - przycisk radio $DFCS_BUTTONRADIOIMAGE - Obraz dla przycisku opcji ( nonsquare potrzebuje obrazu ) $DFCS_BUTTONRADIOMASK - Maska dla przycisku opcji ( nonsquare potrzebuje maski ) ------------------------------------------------------------------------------------ Jeśli $nType jest $DFC_CAPTION , $nState może być jedną z następujących wartości: ------------------------------------------------------------------------------------ $DFCS_CAPTIONCLOSE - przycisk Zamknij $DFCS_CAPTIONHELP - przycisk Help $DFCS_CAPTIONMAX - przycisk Maksymalizuj $DFCS_CAPTIONMIN - przycisk Minimalizuj $DFCS_CAPTIONRESTORE - przycisk Restore ------------------------------------------------------------------------------------ Jeśli $nType jest $DFC_MENU , $ nState może być jedną z następujących wartości : ------------------------------------------------------------------------------------ $DFCS_MENUARROW - strzałka w prawo (rozwijanie podmenu) $DFCS_MENUARROWRIGHT - strzałka w lewo $DFCS_MENUBULLET - kropka $DFCS_MENUCHECK - zaznaczenia ------------------------------------------------------------------------------------ Jeśli $nType jest $DFC_SCROLL , $nState może być jedną z następujących wartości : ------------------------------------------------------------------------------------ $DFCS_SCROLLCOMBOBOX - strzałka w dół (pasek przewijania Combo box) $DFCS_SCROLLDOWN - strzałka w dół z paska przewijania $DFCS_SCROLLLEFT - strzałka w lewo z paska przewijania $DFCS_SCROLLRIGHT - Strzałka w prawo z paska przewijania $DFCS_SCROLLSIZEGRIP - uchwyt zmiany wielkości okna (prawy) $DFCS_SCROLLSIZEGRIPRIGHT - uchwyt zmiany wielkości okna (lewy) $DFCS_SCROLLUP - strzałka w górę z paska przewijania ------------------------------------------------------------------------------------ Następujących wartości mogą być dodane w celu ustawienia stanu elementu: ------------------------------------------------------------------------------------ $DFCS_CHECKED - przycisk jest zaznaczony $DFCS_FLAT - przycisk z płaskim obramowaniem $DFCS_INACTIVE - przycisk jest nieaktywny (szary) $DFCS_PUSHED - przycisk jest wciśnięty
Przykład:
#include <FrameConstants.au3>
#include <GUIConstantsEx.au3>
#include <WinAPI.au3>
;tworzenie GUI
$hGUI = GUICreate("_WinAPI_DrawFrameControl", 300, 300)
GUISetState()
$hDC = _WinAPI_GetDC($hGUI)
$tRect = DllStructCreate($tagRECT)
$ptrRect = DllStructGetPtr($tRect)
$DFC = $DFC_CAPTION ;elementy paska tytułu
SetPosSize($tRect, 20, 25, 22, 22)
_WinAPI_DrawFrameControl($hDC, $ptrRect, $DFC, $DFCS_CAPTIONCLOSE)
SetPosSize($tRect, 50, 25, 22, 22)
_WinAPI_DrawFrameControl($hDC, $ptrRect, $DFC, $DFCS_CAPTIONHELP + $DFCS_INACTIVE)
SetPosSize($tRect, 80, 25, 22, 22)
_WinAPI_DrawFrameControl($hDC, $ptrRect, $DFC, $DFCS_CAPTIONMIN)
SetPosSize($tRect, 110, 25, 22, 22)
_WinAPI_DrawFrameControl($hDC, $ptrRect, $DFC, $DFCS_CAPTIONRESTORE + $DFCS_PUSHED)
$DFC = $DFC_MENU ;elementy menu
SetPosSize($tRect, 20, 65, 22, 22)
_WinAPI_DrawFrameControl($hDC, $ptrRect, $DFC, $DFCS_MENUARROW)
SetPosSize($tRect, 50, 65, 22, 22)
_WinAPI_DrawFrameControl($hDC, $ptrRect, $DFC, $DFCS_MENUARROWRIGHT)
SetPosSize($tRect, 80, 65, 22, 22)
_WinAPI_DrawFrameControl($hDC, $ptrRect, $DFC, $DFCS_MENUBULLET)
SetPosSize($tRect, 110, 65, 40, 40)
_WinAPI_DrawFrameControl($hDC, $ptrRect, $DFC, $DFCS_MENUCHECK)
;zwolnienie zasobów
_WinAPI_ReleaseDC($hGUI, $hDC)
Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE
Func SetPosSize(ByRef $tRect, $x, $y, $w, $h)
DllStructSetData($tRect, "Left", $x)
DllStructSetData($tRect, "Top", $y)
DllStructSetData($tRect, "Right", $x + $w)
DllStructSetData($tRect, "Bottom", $y + $h)
EndFunc
_WinAPI_FillRect
edytuj#include <WinAPI.au3> _WinAPI_FillRect($hDC, $ptrRect, $hBrush)
Funkcja zamalowuje prostokąt podanym pędzlem. Zwraca True gdy sukces, lub False gdy wystąpił błąd.
$hDC - uchwyt do kontekstu
$ptrRect - wskaźnik do struktury $tagRECT z opisem położenie i wielkości prostokąta
$hBrush - uchwyt do pędzla, lub powiększony o 1 kod jednego z kolorów systemowych. Kody kolorów systemowych od 0 do 30 (np. 13 to kolor wybranej pozycji w kontrolce).
Przykład:
#include <GUIConstantsEx.au3>
#include <WinAPI.au3>
$hGUI = GUICreate("WinAPI", 400, 300)
$hDC = _WinAPI_GetWindowDC($hGUI)
GUISetState()
;tworzenie pędzla (czerwony)
$hBrush = _WinAPI_CreateSolidBrush(0x0000FF)
;tworzenie struktury z danymi prostokąta
$tRect = DllStructCreate($tagRECT)
DllStructSetData($tRect, "Left", 20)
DllStructSetData($tRect, "Top", 50)
DllStructSetData($tRect, "Right", 200)
DllStructSetData($tRect, "Bottom", 200)
;odczyt wskaźnika do struktury
$ptrRect = DllStructGetPtr($tRect)
;zamalowanie prostokąta zdefiniowanym pędzlem
_WinAPI_FillRect($hDC, $ptrRect, $hBrush)
DllStructSetData($tRect, "Left", 210)
DllStructSetData($tRect, "Right", 390)
;zamalowanie prostokąta standardowym kolorem
_WinAPI_FillRect($hDC, $ptrRect, 29+1)
Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE
;zwolnienie zasobów
_WinAPI_DeleteObject($hBrush)
_WinAPI_ReleaseDC($hGUI, $hDC)
_WinAPI_FrameRect
edytuj#include <WinAPI.au3> _WinAPI_FrameRect($hDC, $ptrRect, $hBrush)
Funkcja rysuje ramkę wokół prostokątnego obszaru za pomocą podanego pędzla. Zwraca True gdy sukces, lub False gdy wystąpił błąd.
$hDC - uchwyt do kontekstu
$ptrRect - wskaźnik do struktury $tagRECT z opisem położenie i wielkości prostokąta
$hBrush - uchwyt do pędzla
Przykład:
#include <GUIConstantsEx.au3>
#include <WinAPI.au3>
$hGUI = GUICreate("WinAPI", 400, 300)
$hDC = _WinAPI_GetWindowDC($hGUI)
GUISetState()
;tworzenie pędzla
$hBrush = _WinAPI_CreateSolidBrush(0x0000FF)
;tworzenie struktury z danymi prostokąta
$tRect = DllStructCreate($tagRECT)
DllStructSetData($tRect, "Left", 20)
DllStructSetData($tRect, "Top", 50)
DllStructSetData($tRect, "Right", 200)
DllStructSetData($tRect, "Bottom", 200)
;odczyt wskaźnika do struktury
$ptrRect = DllStructGetPtr($tRect)
;rysowanie ramki wokół prostokąta
_WinAPI_FrameRect($hDC, $ptrRect, $hBrush)
Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE
;zwolnienie zasobów
_WinAPI_DeleteObject($hBrush)
_WinAPI_ReleaseDC($hGUI, $hDC)
Ikony i kursory
edytuj_WinAPI_DrawIcon
edytuj#include <WinAPI.au3> _WinAPI_DrawIcon($hDC, $iX, $iY, $hIcon)
Funkcja rysuje ikonę w określonym kontekście urządzenia. Zwraca True gdy sukces, lub False gdy wystąpił błąd.
$hDC - uchwyt do kontekstu urządzenia
$iX i $iY - współrzędne lewego górnego rogu ikony
$hIcon - uchwyt do ikony
_WinAPI_DrawIconEx
edytuj#include <WinAPI.au3> _WinAPI_DrawIconEx($hDC, $iX, $iY, $hIcon [, $iWidth = 0 [, $iHeight = 0 [, $iStep = 0 [, $hBrush = 0 [, $iFlags = 3]]]]])
Funkcja rysuje ikonę w określonym kontekście urządzenia. Zwraca True gdy sukces, lub False gdy wystąpił błąd.
$hDC - uchwyt do kontekstu urządzenia
$iX i $iY - współrzędne lewego górnego rogu ikony
$hIcon - uchwyt do ikony
$iWidth i $iHeight - szerokość i wysokość ikony lub kursora, 0 szerokość domyślna
$iStep - indeks kadru animowanego kursora, parametr jest ignorowany gdy ikona nie jest animowanym kursorem
$hBrush - uchwyt pędzla do tworzenia migotania kursora
$iFlags - parametr ten może być jedna z następujących wartości:
1 - rysowanie ikony lub kursora za pomocą maski 2 - rysowanie ikony lub kursora za pomocą obrazu 3 - rysowanie ikony lub kursora za pomocą maski i obrazu
_WinAPI_LoadShell32Icon
edytuj#include <WinAPI.au3> _WinAPI_LoadShell32Icon($iIconID)
Funkcja odczytuje i zwraca uchwyt do ikony z pliku Shell32.dll, lub 0 gdy wystąpił błąd.
$iIconID - ID ikony w pliku Shell32.dll
_WinAPI_CopyIcon
edytuj#include <WinAPI.au3> _WinAPI_CopyIcon($hIcon)
Funkcja tworzy duplikat ikony. Zwraca uchwyt do duplikatu, lub 0 gdy wystąpił błąd.
$hIcon - uchwyt do kopiowanej ikony
_WinAPI_DestroyIcon
edytuj#include <WinAPI.au3> _WinAPI_DestroyIcon($hIcon)
Funkcja usuwa z pamięci ikonę o podanym uchwycie. Zwraca True gdy sukces, lub False gdy wystąpił błąd.
$hIcon - uchwyt do usuwanej ikony
Przykład:
#include <GUIConstantsEx.au3>
#include <WinAPI.au3>
;tworzenie GUI
$hGUI = GUICreate("_WinAPI_DrawIcon", 400, 300)
$hDC = _WinAPI_GetDC($hGUI)
GUISetState()
;odczyt uchwytu do ikony
$hIcon1 = _WinAPI_LoadShell32Icon(4)
;rysowanie ikony
_WinAPI_DrawIcon($hDC, 20, 40, $hIcon1)
;tworzenie duplikatu ikony
$hIcon2 = _WinAPI_CopyIcon($hIcon1)
;rysowanie ikony
_WinAPI_DrawIconEx($hDC, 100, 40, $hIcon2, 160, 160)
;zwolnienie zasobów
_WinAPI_ReleaseDC($hGUI, $hDC)
_WinAPI_DestroyIcon($hIcon1)
_WinAPI_DestroyIcon($hIcon2)
Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE
_WinAPI_SetCursor
edytuj#include <WinAPI.au3> _WinAPI_SetCursor($hCursor)
Funkcja ustawia kształt kursora. Zwraca uchwyt do poprzedniego kursora (o ile taki istniał), lub gdy nie było kursora.
$hCursor - uchwyt do nowego kursora
Przykład:
#include <GUIConstantsEx.au3>
#include <WinAPI.au3>
$hCursor = 0x1000b
$hGUI = GUICreate("_WinAPI_SetCursor", 400, 300)
GUISetState()
Do
_WinAPI_SetCursor($hCursor)
Until GUIGetMsg() = $GUI_EVENT_CLOSE
_WinAPI_GetCursorInfo
edytuj#include <WinAPI.au3> _WinAPI_GetCursorInfo()
Funkcja zwraca informacje o kursorze w postaci jednowymiarowej tablicy. Jeżeli wystąpi błąd makro @error<>0.
Informacje w zwracanej tablicy:
[0] - zawsze True [1] - True jeżeli kursor jest widoczny, w przeciwnym razie False [2] - uchwyt do kursora [3] - współrzędna pozioma kursora (globalna) [4] - współrzędna pionowa kursora (globalna)
Przykład:
#include <GUIConstantsEx.au3>
#include <WinAPI.au3>
;odczyt informacji o kursorze
$arr = _WinAPI_GetCursorInfo()
;tekst do wyświetlenia
$Cursorinfo = " Zawsze : " & $arr[0] & @LF & _
" Widoczny?: " & $arr[1] & @LF & _
" Uchwyt : " & $arr[2] & @LF & _
" Pozycja X: " & $arr[3] & @LF & _
" Pozycja Y: " & $arr[4]
;tworzenie GUI
$hGUI = GUICreate("Kursor", 200, 300)
GUICtrlCreateLabel("DANE KURSORA", 58, 20,120,70)
GUICtrlCreateLabel("IKONA KURSORA", 58, 150,120,70)
$lab = GUICtrlCreateLabel($Cursorinfo, 40, 40,120,70)
GUICtrlSetBkColor($lab,0xffff00)
$hDC = _WinAPI_GetDC($hGUI)
GUISetState()
;rysowanie ikony kursora
_WinAPI_DrawIconEx($hDC, 60, 190, $arr[2], 100, 100)
Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE
_WinAPI_GetIconInfo
edytuj#include <WinAPI.au3> _WinAPI_GetIconInfo($hIcon)
Funkcja zwraca w postaci jednowymiarowej tablicy informacje o określonej ikonie lub kursorze. Jeżeli wystąpi błąd makro @error<>0.
Informacje w zwracanej tablicy:
[0] - zawsze True [1] - True oznacza ikonę, False kursor [2] - współrzędna pozioma "hot spotu" kursora [3] - współrzędna pionowa "hot spotu" kursora [4] - uchwyt do maski ikony [5] - uchwyt do kolorowej bitmapy ikony
Dla ikon "hot spot" jest zawsze w środku ikony.
$hIcon - uchwyt do ikony lub jeden z poniższych kodów (dla W7):
0x10003 - normalna strzałka 0x10005 - pionowy kursor tekstowy (I) 0x10007 - koło (oczekiwanie na zakończenie operacji) 0x10009 - krzyż 0x1000B - strzałka w górę 0x1000D - dwustronna strzałka pochylona w prawo 0x1000F - dwustronna strzałka pochylona w prawo 0x10011 - dwustronna strzałka pozioma 0x10013 - dwustronna strzałka pionowa 0x10015 - krzyż z 4 strzałkami na ramionach 0x10017 - znak "STOP" 0x10019 - strzałka z kółkiem 0x1001B - strzałka ze znakiem zapytania 0x1001D - pióro 0x1001F - rączka 0x10021 - przycisk 0x10023 - strzałka z płytą 0x10025 - ikona aplikacji 0x10027 - ikona aplikacji 0x10029 - ostrzeżenie (wykrzyknik w żółtym trójkącie) 0x1002B - znak zapytania 0x1002D - krzyż w czerwonym kole 0x1002F - informacja (i w niebieskim kole) 0x10031 - ikona aplikacji 0x10033 - tarcza
Przykład:
#include <GUIConstantsEx.au3>
#include <WinAPI.au3>
$kod=0x00002D
;odczyt informacji o kursorze
$arr = _WinAPI_GetIconInfo($kod)
;tekst do wyświetlenia
$IconInfo = " KOD=" & $kod & " (" & Ptr($kod) & ")" & @LF & _
"-------------------------------------" & @LF & _
" Zawsze : " & $arr[0] & @LF & _
" Ikona? : " & $arr[1] & @LF & _
" X hot spot : " & $arr[2] & @LF & _
" Y hot spot : " & $arr[2] & @LF & _
" Uchwyt maski: " & $arr[4] & @LF & _
" Uchwyt bitmapy: " & $arr[5]
;tworzenie GUI
$hGUI = GUICreate("Kursor", 200, 305)
GUICtrlCreateLabel("DANE IKONY", 58, 15,120,70)
GUICtrlCreateLabel("WYGLĄD IKONY", 58, 180,120,70)
$hLab = GUICtrlCreateLabel($IconInfo, 15, 35,170,135)
GUICtrlSetBkColor($hLab,0xffff00)
GUISetState()
;odczyt uchwytu do kontekstu przestrzeni roboczej okna
$hDC = _WinAPI_GetDC($hGUI)
;rysowanie ikony
_WinAPI_DrawIconEx($hDC, 50, 200, $kod, 100, 100)
Do
Sleep(50)
_WinAPI_DrawIconEx($hDC, 50, 200, $kod, 100, 100)
Until GUIGetMsg() = $GUI_EVENT_CLOSE
;zwolnienie zasobów
_WinAPI_ReleaseDC ($hGUI, $hDC)
_WinAPI_ShowCursor
edytuj#include <WinAPI.au3> _WinAPI_ShowCursor($fShow)
Funkcja włącza/wyłącza wyświetlanie kursora w oknie skryptu. Zwraca nowy stan licznika wyświetlania, 0 - kursor wyświetlany, -1 - kursor ukryty.
$fShow - True - kursor będzie wyświetlany, False - kursor będzie ukryty
Przykład:
#include <WinAPI.au3>
#include <GUIConstantsEx.au3>
$iCount = 0
$hGui = GUICreate('Kursor widoczny', 350, 200)
$iButton = GUICtrlCreateButton('Schowaj kursor', 10, 10, 330, 28)
GUISetState()
Do
Switch GUIGetMsg()
Case $iButton
If $iCount Then
$iCount = _WinAPI_ShowCursor(True)
GUICtrlSetData($iButton, 'Schowaj kursor')
WinSetTitle($hGui, '','Kursor widoczny, licznik = ' & $iCount)
Else
$iCount = _WinAPI_ShowCursor(False)
GUICtrlSetData($iButton, 'Pokaż kursor')
WinSetTitle($hGui, '','Kursor niewidoczny, licznik = ' & $iCount)
EndIf
Case $GUI_EVENT_CLOSE
Exit
EndSwitch
Until False
_WinAPI_SaveHICONToFile
edytuj#include <WinAPIGdi.au3> _WinAPI_SaveHICONToFile ( $sFilePath, $vIcon [, $bCompress = False [, $iStart = 0 [, $iEnd = -1]]] )
Funkcja zapisuje ikonę na dysku. Zwraca 1 gdy sukces, lub 0 gdy wystąpił błąd.
$sFilePath - nazwa pliku ze ścieżką dostępu
$vIcon - uchwyt do ikony lub tablica uchwytów ikon (jeżeli plik ma zawierać kolekcję ikon)
$bCompress - określa czy użyć kompresji PNG przy zapisie ikon 32-bitowych. True - tak, False - nie
$iStart - (tylko dla tablicy uchwytów) indeks pierwszej ikony do zapisu na dysku
$iEnd - (tylko dla tablicy uchwytów) indeks ostatniej ikony do zapisu, domyślna wartość -1 oznacza ostatni indeks w tablicy
Przykład:
#include <GDIPlus.au3>
;#include <WinAPIGdi.au3> nie jest konieczne, gdyż GDIPlus.au3 używa WinAPIGdi.au3
Opt('TrayMenuMode', 3)
_GDIPlus_Startup()
$sFile = FileOpenDialog("Wybierz obrazek", "", "Obrazy (*.bmp;*.png;*.jpg;*.gif;*.tif)")
$hBitmap = _GDIPlus_ImageLoadFromFile($sFile) ;wczytanie bitmapy z dysku
$hIcon = _GDIPlus_HICONCreateFromBitmap($hBitmap) ;tworzenie ikony z bitmapy
_WinAPI_SaveHICONToFile('MyIcon.ico', $hIcon) ;zapisanie ikony na dysku
;zwolnienie zasobów
_GDIPlus_BitmapDispose($hBitmap)
_GDIPlus_Shutdown()
;tworzenie menu w tray'u
$hMenu = TrayItemGetHandle(0)
$idView = TrayCreateItem('Wyświetlenie obrazu ikony')
TrayCreateItem('')
$idExit = TrayCreateItem('Koniec')
TraySetIcon('MyIcon.ico') ;zmiana ikony w tray'u
TraySetState()
TrayTip("Uwaga", 'Zmiana ikony w tray', 30)
Do
$idMsg = TrayGetMsg()
If $idMsg = $idExit Then Exit
if $idMsg = $idView Then
SplashImageOn('', $sFile)
Sleep(3000)
SplashOff()
EndIf
Until 0
Regiony (Window Regions)
edytujKażde okno w Windows ma zdefiniowany region, który jest widoczny dla użytkownika. Normalnie system operacyjny ustala ten region na całą powierzchnię okna. Istnieją jednak możliwość programowego ograniczenia widocznego obszaru okna poprzez zdefiniowanie własnego regionu. Po za tym regionem okno będzie niewidoczne i przeźroczyste.
Samo ustalenie regionu nie ma wpływu na kształt całego okna, więc istnieje możliwość zmiany regonu w czasie działania skryptu. Samo okno nie zmienia się, zmienia się tylko kształt obszaru, w którym to okno jest widoczne.
UWAGA:
1. Wszystkie współrzędne używane do definiowania regionów odnoszą się do całego okna, a nie jego przestrzeni roboczej.
2. Nie należy usuwać uchwytów regionu. System sam usuwa uchwyty, gdy nie są już potrzebne.
Poniżej kilka funkcji do operowania regionami.
_WinAPI_CreateRectRgn
edytuj#include <WinAPI.au3> _WinAPI_CreateRectRgn($iLeftRect, $iTopRect, $iRightRect, $iBottomRect)
Funkcja tworzy prostokątny region. Zwraca uchwyt do regionu, lub 0 gdy wystąpił błąd.
$iLeftRect i $iTopRect - współrzędna lewego górnego narożnika prostokąta
$iRightRect i $iBottomRect - współrzędna prawego dolnego narożnika prostokąta
UWAGA:
1. Wszystkie współrzędne używane do definiowania regionów odnoszą się do całego okna, a nie jego przestrzeni roboczej.
2. Nie należy usuwać uchwytów regionu. System sam usuwa uchwyty, gdy nie są już potrzebne.
_WinAPI_CreateRoundRectRgn
edytuj#include <WinAPI.au3> _WinAPI_CreateRoundRectRgn($iLeftRect, $iTopRect, $iRightRect, $iBottomRect, $iWidthEllipse, $iHeightEllipse)
Funkcja tworzy prostokątny region z zaokrąglonymi narożnikami. Zwraca uchwyt do regionu, lub 0 gdy wystąpił błąd.
$iLeftRect i $iTopRect - współrzędna lewego górnego narożnika prostokąta
$iRightRect i $iBottomRect - współrzędna prawego dolnego narożnika prostokąta
$iRightRect i $iBottomRect - szerokość i wysokość elipsy tworzącej zaokrąglenia narożników
_WinAPI_CombineRgn
edytuj#include <WinAPI.au3> _WinAPI_CombineRgn($hRgnDest, $hRgnSrc1, $hRgnSrc2, $iCombineMode)
Funkcja tworzy region będący kombinacją dwóch innych regionów. Zwraca typ powstałego regionu, lub 0 gdy wystąpił błąd.
Zwracane wartości:
$NULLREGION = 1 - region jest pusty $SIMPLEREGION = 2 - pojedynczy prostokąt $COMPLEXREGION = 3 - region kompleksowy zawierający więcej elementów
Parametry:
$hRgnDest - uchwyt do nowego regionu o wymiarach odpowiadających kombinacji dwóch pozostałych regionów. Region ten musi być wcześniej zdefiniowany w sposób dowolny, gdyż i tak zostanie nadpisany poprzez referencję.
$hRgnSrc1 i $hRgnSrc2 - uchwyty do dwóch regionów, których kombinację tworzymy
$iCombineMode - parametr określający sposób łączenia dwóch regionów. Może być jedną z poniższych wartości:
$RGN_AND = 1 - część wspólna $RGN_OR = 2 - suma obu regionów $RGN_XOR = 3 - suma regionów z wyłączeniem części wspólnej $RGN_DIFF = 4 - drugi region odjęty od pierwszego $RGN_COPY = 5 - kopia pierwszego regionu
_WinAPI_SetWindowRgn
edytuj#include <WinAPI.au3> _WinAPI_SetWindowRgn($hWnd, $hRgn [, $bRedraw])
Funkcja aktywuj region o podanym uchwycie. Zwraca liczbę <>0 gdy sukces, lub 0 gdy wystąpił błąd.
$hWnd - uchwyt do okna, którego dotyczyć będzie aktywowany region
$hRgn - uchwyt do zdefiniowanego regionu
$bRedraw - określa czy system ma odświeżyć okno po aktywowaniu regionu
Przykład manipulowania regionami:
#include <GUIConstantsEx.au3>
#include <WindowsConstants.au3>
#include <WinAPI.au3>
;tworzenie testowego GUI
$hGUI = GUICreate(" Test Windows regions", 350, 210)
GUISetBkColor(0xff0000, $hGUI)
$btn_exit = GUICtrlCreateButton("Wyjście", 100, 150, 150)
$lab = GUICtrlCreateLabel("To jest testowe okno", 55, 40,150,85)
GUICtrlSetBkColor($lab,0xffff00)
GUISetState(@SW_SHOW)
$pos = WinGetPos($hGUI)
$width = $pos[2]
$height = $pos[3]
;okno normalne
Do
$msg = GUIGetMsg()
Until $msg = $GUI_EVENT_CLOSE Or $msg = $btn_exit
;region prostokątny
$rgn = _WinAPI_CreateRectRgn(10, 10, 200, 200)
_WinAPI_SetWindowRgn($hGUI, $rgn)
Do
$msg = GUIGetMsg()
Until $msg = $GUI_EVENT_CLOSE Or $msg = $btn_exit
;region z zaokrąglonymi narożnikami
$rgn = _WinAPI_CreateRoundRectRgn(0, 0, $width, $height,$width, $height)
_WinAPI_SetWindowRgn($hGUI, $rgn)
Do
$msg = GUIGetMsg()
Until $msg = $GUI_EVENT_CLOSE Or $msg = $btn_exit
;region kombinowany
$rgn = _WinAPI_CreateRectRgn(0, 0, $width, $height)
$rgn1 = _WinAPI_CreateRoundRectRgn(0, 0,200, 200,200, 200)
$rgn2 = _WinAPI_CreateRoundRectRgn(220, 100,350,210, 50, 50)
_WinAPI_CombineRgn($rgn, $rgn1, $rgn2, 2)
_WinAPI_SetWindowRgn($hGUI, $rgn)
Do
$msg = GUIGetMsg()
Until $msg = $GUI_EVENT_CLOSE Or $msg = $btn_exit
;region kombinowany z przezroczystym tłem
$rgn = _WinAPI_CreateRectRgn(0, 0, $width, $height)
$rgn2 = _WinAPI_CreateRectRgn(8, 28, 349, 232)
$rgn3 = _WinAPI_CreateRectRgn(104, 176, 252, 199)
_WinAPI_CombineRgn($rgn, $rgn, $rgn2, 3)
_WinAPI_CombineRgn($rgn, $rgn, $rgn3, 2)
_WinAPI_SetWindowRgn($hGUI, $rgn)
Do
$msg = GUIGetMsg()
Until $msg = $GUI_EVENT_CLOSE Or $msg = $btn_exit
_WinAPI_GetWindowRgn
edytuj#include <WinAPI.au3> _WinAPI_GetWindowRgn($hWnd, $hRgn)
Funkcja odczytuje uchwyt do aktualnie ustawionego regionu. Zwraca typ regionu (jak _WinAPI_CombineRgn), lub 0 gdy wystąpił błąd.
$hWnd - uchwyt do okna, którego region będzie odczytywany
$hRgn - uchwyt do regionu, może być dowolny, gdyż zostanie nadpisany przez referencję odczytywanym regionem okna. Najprościej stworzyć dowolny region funkcją _WinAPI_CreateRectRgn.
Przykład:
#include <GUIConstantsEx.au3>
#include <WindowsConstants.au3>
#include <WinAPI.au3>
;tworzenie testowego GUI
$hGUI = GUICreate(" Test Windows regions", 350, 210)
GUISetBkColor(0xff0000, $hGUI)
$btn_exit = GUICtrlCreateButton("Wyjście", 100, 150, 150)
$lab = GUICtrlCreateLabel("To jest testowe okno", 55, 40,150,85)
GUICtrlSetBkColor($lab,0xffff00)
GUISetState(@SW_SHOW)
;okno wyjściwe
Do
$msg = GUIGetMsg()
Until $msg = $GUI_EVENT_CLOSE Or $msg = $btn_exit
;ustalenie regionu
_WinAPI_SetWindowRgn($hGUI, _WinAPI_CreateRectRgn(0, 0, 200, 210))
Do
$msg = GUIGetMsg()
Until $msg = $GUI_EVENT_CLOSE Or $msg = $btn_exit
;tworzenie dowolnego regionu
$hrgn = _WinAPI_CreateRectRgn(0, 0, 0, 0)
;odczyt uchwytu aktualnego regionu
_WinAPI_GetWindowRgn($hGUI, $hrgn)
;zmiana regionu
_WinAPI_SetWindowRgn($hGUI, _WinAPI_CreateRectRgn(0, 0, 200, 20))
Do
$msg = GUIGetMsg()
Until $msg = $GUI_EVENT_CLOSE Or $msg = $btn_exit
;odtworzenie regionu
_WinAPI_SetWindowRgn($hGUI, $hrgn)
Do
$msg = GUIGetMsg()
Until $msg = $GUI_EVENT_CLOSE Or $msg = $btn_exit
Funkcje związane z oknami i ekranem
edytujW systemie Windows istnieje wiele różnych typów okien. Okna overlapped to standardowe okna z ramką i napisem tytułowym. Okna typu child to okna potomne, wyświetlane w obszarze roboczym swojego okna rodzica. Kiedy przesuwasz po ekranie okno rodzica, to razem z nim przesuwają się wszystkie jego okna-dzieci. Okna typu popup to również okna potomne, wyświetlane jednak niezależnie od położenia i rozmiarów okna rodzica. Okna potomne znajdują się zawsze nad swoim oknem-rodzicem (nie mogą być przez nie zasłonięte). Również obiekty sterujące typu: przyciski, listbox'y, paski przewijania i inne opisane niżej obiekty są oknami.
_WinAPI_CreateWindowEx
edytuj#include <WinAPI.au3> _WinAPI_CreateWindowEx($iExStyle, $sClass, $sName, $iStyle, $iX, $iY, $iWidth, $iHeight, $hParent [, $hMenu = 0 [, $hInstance = 0 [, $pParam = 0]]])
Funkcja zwraca uchwyt do tworzonego okna, lub 0 gdy wystąpił błąd.
$iExStyle - rozszerzony styl okna
$sClass - nazwa klasy okna, np.: BUTTON, COMBOBOX, EDIT, LISTBOX, MDICLIENT, SCROLLBAR, STATIC
$sName - nazwa okna
$iStyle - styl okna
$iX, $iY - współrzędne lewego górnego narożnika okna
$iWidth, $iHeight - szerokość i wysokość okna
$hParent - uchwyt okna nadrzędnego
$hMenu - uchwyt do menu lub numer kontrolki
$hInstance - uchwyt instancji
$pParam - parametr używany przy tworzeniu okna MDI (Multiple Document Interface)
UWAGA: $iExStyle i $iStyle wg rozdziału AutoIt / GUI / Opis funkcji GUI / Tworzenie okna GUI.
_WinAPI_DestroyWindow
edytuj#include <WinAPI.au3> _WinAPI_DestroyWindow($hWnd)
Funkcja niszczy okno o podanym uchwycie. Zwraca True gdy sukces, lub False gdy wystąpił błąd.
$hWnd - uchwyt do okna
Przykład:
#include <WinAPI.au3>
#include <WindowsConstants.au3>
#include <GUIConstantsEx.au3>
$hGui = GUICreate('CreateWindowEx', 240, 60)
$hEdit = _WinAPI_CreateWindowEx($WS_EX_CLIENTEDGE, "Edit", "Mały test", _
BitOR($WS_CHILD, $WS_VISIBLE), 10, 10, 140, 22, $hGui)
$hButton = _WinAPI_CreateWindowEx($WS_EX_DLGMODALFRAME, "Button", "Przycisk", _
BitOR($WS_CHILD, $WS_VISIBLE), 160, 10, 70, 22, $hGui)
GUISetState()
Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE
_WinAPI_DestroyWindow($hEdit)
Sleep(1000)
_WinAPI_DestroyWindow($hButton)
Sleep(1000)
_WinAPI_ShowWindow
edytuj#include <WinAPI.au3> _WinAPI_ShowWindow ( $hWnd [, $iCmdShow = 5] )
Funkcja ustawia określony stan wyświetlanego okna. Zwraca True gdy sukces, lub False gdy wystąpił błąd.
$hWnd - uchwyt okna
$iCmdShow - określa w jaki sposób wyświetlane jest okno:
@SW_HIDE - ukrywa okno @SW_MAXIMIZE - maksymalizuje okno @SW_MINIMIZE - minimalizuje okno i aktywuje następne w kolejności wg kolejności nakładania (Z-order) @SW_RESTORE - wyświetla i aktywuje okno @SW_SHOW - wyświetla i aktywuje okno w domyślnej wielkości i położeniu @SW_SHOWDEFAULT - ustawia stan wyświetlania okna w oparciu o SW_flag określonej w strukturze STARTUPINF @SW_SHOWMAXIMIZED - wyświetla i aktywuje zmaksymalizowane okno @SW_SHOWMINIMIZED - wyświetla i aktywuje zminimalizowane okno @SW_SHOWMINNOACTIVE - wyświetla zminimalizowane okno @SW_SHOWNA - wyświetla okno z aktualnymi ustawieniami @SW_SHOWNOACTIVATE - wyświetla w domyślnej wielkości i położeniu @SW_SHOWNORMAL - wyświetla i aktywuje okno
_WinAPI_RedrawWindow
edytuj#include <WinAPI.au3> _WinAPI_RedrawWindow ( $hWnd [, $tRECT = 0 [, $hRegion = 0 [, $iFlags = 5]]] )
Funkcja aktualizuje określony prostokąt lub region, w obszarze roboczym danego okna. Zwraca True gdy sukces, lub False gdy wystąpił błąd.
$hWnd - uchwyt okna
$tRect - struktura $tagRECT zawierająca dane o położeniu i wielkości prostokątnego obszaru, parametr jest ignorowany, gdy w $hRegion podano uchwyt do zdefiniowanego regionu aktualizacji
$hRegion - uchwyt do zdefiniowanego regionu aktualizacji, jeżeli $hRegion=0 i $tRect=0 aktualizowany jest cały obszar klienta
$iFlags - flaga definiująca sposób przerysowania okna, może być kombinacją następujących wartości (zdefiniowane w <WindowsConstants.au3>):
$RDW_ERASE - Causes the window to receive a WM_ERASEBKGND message when the window is repainted $RDW_FRAME - Causes any part of the nonclient area of the window that intersects the update region to receive a WM_NCPAINT message. $RDW_INTERNALPAINT - Causes a WM_PAINT message to be posted to the window regardless of whether any portion of the window is invalid. $RDW_INVALIDATE - Invalidates $tRECT or $hRegion. If both are 0, the entire window is invalidated. $RDW_NOERASE - Suppresses any pending $WM_ERASEBKGND messages $RDW_NOFRAME - Suppresses any pending $WM_NCPAINT messages $RDW_NOINTERNALPAINT - Suppresses any pending internal $WM_PAINT messages $RDW_VALIDATE - Validates $tRECT or $hRegion $RDW_ERASENOW - Causes the affected windows to receive $WM_NCPAINT and $WM_ERASEBKGND messages, if necessary, before the function returns $RDW_UPDATENOW - Causes the affected windows to receive $WM_NCPAINT, $WM_ERASEBKGND, and $WM_PAINT messages, if necessary, before the function returns. $RDW_ALLCHILDREN - Includes child windows in the repainting operation $RDW_NOCHILDREN - Excludes child windows from the repainting operation
_WinAPI_InvalidateRect
edytuj#include <WinAPI.au3> _WinAPI_InvalidateRect($hWnd [, $tRect = 0 [, $fErase = True]])
Funkcja powoduje odświeżenie prostokątnego obszaru okna.
$hWnd - uchwyt okna, 0 oznacza cały desktop
$tRect - struktura $tagRECT zawierająca dane o położeniu i wielkości prostokątnego obszaru
$fErase - określa czy ma być kasowane tło okna, True - tło kasowane, False - tło bez zmian
Przykład:
#include <WindowsConstants.au3>
#include <WinAPI.au3>
#include <GDIPlus.au3>
Local $tRect = DllStructCreate($tagRECT)
$hGUI = GUICreate("Okno testowe", 400, 450, 200, 200)
GUISetState()
test_picture()
MsgBox(0, "", "Odświerzenie obszaru wewnątrz okna")
DllStructSetData($tRect, "Left", 100)
DllStructSetData($tRect, "Top", 50)
DllStructSetData($tRect, "Right", 250)
DllStructSetData($tRect, "Bottom", 300)
_WinAPI_InvalidateRect($hGui, $tRect)
MsgBox(0, "", "Odświerzenie całego okna")
_WinAPI_InvalidateRect($hGui, 0)
Sleep(3000)
Func test_picture()
$hGUIDC = _WinAPI_GetDC($hGUI)
$hDC = _WinAPI_GetWindowDC(0)
_WinAPI_BitBlt($hGUIDC, 0, 0, 400, 450, $hDC, 0, 0, $SRCCOPY)
_WinAPI_ReleaseDC (0, $hDC)
_WinAPI_ReleaseDC ($hGUI, $hGUIDC)
EndFunc
_WinAPI_IsWindow
edytuj#include <WinAPI.au3> _WinAPI_IsWindow($hWnd)
Funkcja sprawdza czy podany uchwyt jest uchwytem istniejącego okna. Zwraca True gdy jest, lub False gdy nie jest.
$hWnd - sprawdzany uchwyt
_WinAPI_IsWindowVisible
edytuj#include <WinAPI.au3> _WinAPI_IsWindowVisible($hWnd)
Funkcja sprawdza czy podany uchwyt jest uchwytem widocznego okna. Zwraca True gdy jest, lub False gdy nie jest.
$hWnd - sprawdzany uchwyt
Przykład:
#include <WinAPI.au3>
$hGui = GUICreate('')
MsgBox(0, 'Test 1', _WinAPI_IsWindowVisible($hGui))
GUISetState()
MsgBox(0, 'Test 2', _WinAPI_IsWindowVisible($hGui))
_WinAPI_EnumWindows
edytuj#include <WinAPI.au3> _WinAPI_EnumWindows([$fVisible = True [, $hwnd = Default]])
Funkcja zwraca listę wszystkich otwartych okien w postaci dwuwymiarowej tablicy:
[0][0] - liczba okien (n) -
[1][0] - uchwyt pierwszego okna
[1][1] - nazwa klasy pierwszego okna
...
[n][0] - uchwyt n-tego okna
[n][1] - nazwa klasy n-tego okna
$fVisible - określa które okna mają być uwzględnione, True - tylko widoczne, False - wszystkie
$hwnd - uchwyt do okna startowego, domyślnie jest to pulpit
Przykład:
#include <WinAPI.au3>
$aWindows = _WinAPI_EnumWindows()
For $i = 1 To $aWindows[0][0]
$text = "Uchwyt okna: " & $aWindows[$i][0] & @LF & @LF
$text &= "Klasa okna: " & $aWindows[$i][1] & @LF & @LF
$text &= "Nazwa okna: " & WinGetTitle($aWindows[$i][0]) & @LF & @LF
$text &= "Tekst w oknie: " & WinGetText($aWindows[$i][0]) & @LF & @LF
$text &= "Nr procesu okna: " & WinGetProcess($aWindows[$i][0])
MsgBox(0, "Otwarte okna: " & $i & " of " & $aWindows[0][0], $text)
Next
_WinAPI_EnumWindowsPopup
edytuj#include <WinAPI.au3> _WinAPI_EnumWindowsPopup()
Funkcja zwraca listę wszystkich otwartych okien typu popup w postaci dwuwymiarowej tablicy:
[0][0] - liczba okien (n) -
[1][0] - uchwyt pierwszego okna
[1][1] - nazwa klasy pierwszego okna
...
[n][0] - uchwyt n-tego okna
[n][1] - nazwa klasy n-tego okna
Przykład:
#include <WinAPI.au3>
$aWindows = _WinAPI_EnumWindowsPopup()
If $aWindows[0][0] = 0 Then
MsgBox(0, "Otwarte okna popup: ", "Brak okien popup.")
else
For $i = 1 To $aWindows[0][0]
$text = "Uchwyt okna: " & $aWindows[$i][0] & @LF & @LF
$text &= "Klasa okna: " & $aWindows[$i][1] & @LF & @LF
$text &= "Nazwa okna: " & WinGetTitle($aWindows[$i][0]) & @LF & @LF
$text &= "Tekst w oknie: " & WinGetText($aWindows[$i][0]) & @LF & @LF
$text &= "Nr procesu okna: " & WinGetProcess($aWindows[$i][0])
MsgBox(0, "Otwarte okna popup: " & $i & " of " & $aWindows[0][0], $text)
Next
EndIf
_WinAPI_EnumWindowsTop
edytuj#include <WinAPI.au3> _WinAPI_EnumWindowsTop()
Funkcja zwraca listę wszystkich otwartych okien najwyższego poziomu w postaci dwuwymiarowej tablicy:
[0][0] - liczba okien (n) -
[1][0] - uchwyt pierwszego okna
[1][1] - nazwa klasy pierwszego okna
...
[n][0] - uchwyt n-tego okna
[n][1] - nazwa klasy n-tego okna
Przykład:
#include <WinAPI.au3>
$aWindows = _WinAPI_EnumWindowsTop()
For $i = 1 To $aWindows[0][0]
$text = "Uchwyt okna: " & $aWindows[$i][0] & @LF & @LF
$text &= "Klasa okna: " & $aWindows[$i][1] & @LF & @LF
$text &= "Nazwa okna: " & WinGetTitle($aWindows[$i][0]) & @LF & @LF
$text &= "Tekst w oknie: " & WinGetText($aWindows[$i][0]) & @LF & @LF
$text &= "Nr procesu okna: " & WinGetProcess($aWindows[$i][0])
MsgBox(0, "Otwarte okna: " & $i & " of " & $aWindows[0][0], $text)
Next
_WinAPI_EnableWindow
edytuj#include <WinAPI.au3> _WinAPI_EnableWindow($hWnd [, $fEnable = True])
Funkcja włącza i wyłącza dostęp myszy i klawiatury do określonego okna i jego kontrolek. Zwraca poprzedni stan okna:
True - okno i kontrolki były dostępne False - okno i kontrolki nie były dostępne
$hWnd - uchwyt do okna
$fEnable - True - udostępnienie okna, False - zablokowanie dostępu
Przykład:
#include <WindowsConstants.au3>
#include <WinAPI.au3>
#include <GUIConstantsEx.au3>
$hGui = GUICreate('Okno testowe', 250, 260, 700, -1, $WS_VISIBLE, $WS_EX_TOPMOST)
$hButton = GUICtrlCreateButton("Przycisk", 90, 30, 70)
_WinAPI_EnableWindow($hGui, False)
MsgBox(0x40000, 'Test', 'W tej chwili okno testowe jest niedostępne,' & @LF & 'po naciśnięciu OK zostanie udostępnione.')
_WinAPI_EnableWindow($hGui, True)
MsgBox(0x40000, 'Test', 'Okno testowe jest dostępne.')
_WinAPI_ClientToScreen
edytuj#include <WinAPI.au3> _WinAPI_ClientToScreen($hWnd, ByRef $tPoint)
Funkcja przelicza współrzędne obszaru roboczego okna na współrzędne ekranowe (bezwzględne). Zwraca strukturę ze współrzędnymi ekranowymi. Jeżeli wystąpi błąd makeo @error przyjmuje kod błędu.
$hWnd - uchwyt do okna
$tPoint - struktura $tagPOINT za współrzędnymi przestrzeni roboczej okna. W wyniku działania struktura przez referencję przyjmie dane dla współrzędnych ekranowych, czyli takie same jakie funkcja zwraca.
Przykład:
#include <WinAPI.au3>
;tworzenie testowego GUI
$hwnd = GUICreate("TOkno testowe", 200, 200,400,300)
GUISetState()
$xc = 0
$yc = 0
;tworzenie struktury i nadanie wartości
$tpoint = DllStructCreate($tagPOINT)
DllStructSetData($tpoint, "X", $xc)
DllStructSetData($tpoint, "Y", $yc)
;odczyt współrzędnych ekranowych
_WinAPI_ClientToScreen($hwnd, $tpoint)
$xs = DllStructGetData($tpoint, "X")
$ys = DllStructGetData($tpoint, "Y")
MsgBox(4096, "_WinAPI_ClientToScreen", "Współrzędne przestrzeni rogoczej okna:" _
& @LF & "Xc = " & $xc & @TAB & @TAB & "Yc = " & $yc & @LF & @LF & _
"Współrzędne ekranu:" & @LF & "Xs = " & $xs & @TAB & @TAB & "Ys = " & $ys & @LF)
_WinAPI_ScreenToClient
edytuj#include <WinAPI.au3> _WinAPI_ScreenToClient($hWnd, ByRef $tPoint)
Funkcja przelicza współrzędne ekranowe (bezwzględne), na współrzędne obszaru roboczego okna . Zwraca True gdy sukces, lub False gdy wystąpił błąd.
$hWnd - uchwyt do okna
$tPoint - struktura $tagPOINT za współrzędnymi ekranowymi. W wyniku działania struktura przez referencję przyjmie dane dla współrzędnych przestrzeni roboczej okna.
Przykład:
#include <GUIConstantsEx.au3>
#include <WinAPI.au3>
$hWnd = GUICreate("Testowe okno", 400, 200)
GUISetState()
Do
$MousePos = MousePos($hWnd)
ToolTip("Ekran:" & @LF & "Xs= " & $MousePos[0] & @LF & "Ys= " & $MousePos[1] & @LF _
& @LF & "Okno:" & @LF & "Xc= " & $MousePos[2] & @LF & "Yc= " & $MousePos[3])
Until GUIGetMsg() = $GUI_EVENT_CLOSE
Func MousePos($hWnd)
Local $MousePos[4], $tPoint = DllStructCreate($tagPOINT)
$MousePos[0] = MouseGetPos(0)
$MousePos[1] = MouseGetPos(1)
DllStructSetData($tPoint, "X", $MousePos[0])
DllStructSetData($tPoint, "Y", $MousePos[1])
;przeliczenie współrzędnych ekranowych na współrzędne okna
_WinAPI_ScreenToClient($hWnd, $tPoint)
$MousePos[2] = DllStructGetData($tPoint, "X")
$MousePos[3] = DllStructGetData($tPoint, "Y")
Return $MousePos
EndFunc
_WinAPI_GetClientRect
edytuj#include <WinAPI.au3> _WinAPI_GetClientRect($hWnd)
Funkcja zwraca współrzędne obszaru roboczego okna w postaci struktury $tagRECT. Jeżeli wystąpił błąd makro @error > 0.
$hWnd - uchwyt do okna
UWAGA: Zwracane wyniki są we współrzędnych obszaru roboczego więc poszczególne pola struktury zawierają:
"Left" - 0 "Right" - szerokość przestrzeni roboczej okna "Top" - 0 "Bottom" - wysokość przestrzeni roboczej okna
Przykład:
#include <WinAPI.au3>
Local $hwnd, $tRect
$hwnd = GUICreate("")
GUISetState()
$tRect = _WinAPI_GetClientRect($hwnd)
MsgBox(4096, "Obszar roboczy:", _
"Lewo..: " & DllStructGetData($tRect, "Left") & @LF & _
"Prawo.: " & DllStructGetData($tRect, "Right") & @LF & _
"Góra...: " & DllStructGetData($tRect, "Top") & @LF & _
"Dół....: " & DllStructGetData($tRect, "Bottom"))
_WinAPI_GetClientHeight
edytuj#include <WinAPI.au3> _WinAPI_GetClientHeight($hWnd)
Funkcja zwraca wysokość obszaru roboczego okna. Jeżeli wystąpił błąd makro @error > 0.
$hWnd - uchwyt do okna
Przykład:
#include <WinAPI.au3>
Local $hwnd, $tRect
$hwnd = GUICreate("")
GUISetState()
$h = _WinAPI_GetClientHeight($hwnd)
MsgBox(4096, "Obszar roboczy:", "Wysokość = " & $h)
_WinAPI_GetClientWidth
edytuj#include <WinAPI.au3> _WinAPI_GetClientWidth($hWnd)
Funkcja zwraca szerokość obszaru roboczego okna. Jeżeli wystąpił błąd makro @error > 0.
$hWnd - uchwyt do okna
Przykład:
#include <WinAPI.au3>
Local $hwnd, $tRect
$hwnd = GUICreate("")
GUISetState()
$w = _WinAPI_GetClientWidth($hwnd)
MsgBox(4096, "Obszar roboczy:", "Szerokość = " & $w)
_WinAPI_GetWindowRect
edytuj#include <WinAPI.au3> _WinAPI_GetWindowRect($hWnd)
Funkcja zwraca współrzędne okna w postaci struktury $tagRECT. Jeżeli wystąpił błąd makro @error > 0.
$hWnd - uchwyt do okna
UWAGA: Zwracane wyniki są we współrzędnych ekranu.
Przykład:
#include <WinAPI.au3>
Local $hwnd, $tRect
$hwnd = GUICreate("")
GUISetState()
$tRect = _WinAPI_GetWindowRect($hwnd)
MsgBox(4096, "Współrzędnr okna:", _
"Lewo..: " & DllStructGetData($tRect, "Left") & @LF & _
"Prawo.: " & DllStructGetData($tRect, "Right") & @LF & _
"Góra...: " & DllStructGetData($tRect, "Top") & @LF & _
"Dół....: " & DllStructGetData($tRect, "Bottom"))
_WinAPI_GetWindowPlacement
edytuj#include <WinAPI.au3> _WinAPI_GetWindowPlacement ( $hWnd )
Funkcja zwraca w postaci struktury $tagWINDOWPLACEMENT informację o umiejscowieniu i wielkości okna na ekranie. Jeżeli wystąpił błąd makro @error przyjmuje wartość różną od zera, a szczegółowe informacje o błędzie można uzyskać wywołując funkcję _WinAPI_GetLastError().
$hWnd - uchwyt do okna
Znaczenie pól struktury $tagWINDOWPLACEMENT:
"length" - wielkość struktury w bajtach
"flags" - określa flagę, która kontroluje pozycję zminimalizowanego okna i metodę, dzięki której okno zostanie przywrócone. Parametr tem może mieć jedną lub więcej z następujących wartości:
$WPF_ASYNCWINDOWPLACEMENT | 4 |
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
$WPF_RESTORETOMAXIMIZED | 2 | Określa, że przywrócone zostanie zmaksymalizowane okno, niezależnie od tego, czy zostało ono zmaksymalizowane zanim został zminimalizowane.
| | To ustawienie jest ważne tylko przy następnym przywróceniu okna.
| | Nie zmienia to zachowanie domyślnego (ustalonego przez parametr funkcji WinSetState() lub GUISetState()) .
| | Flaga ta jest ważna tylko wtedy, gdy pole "showcmd" ma wartość @SW_SHOWMINIMIZED.
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
$WPF_SETMINPOSITION | 1 | Określa, że współrzędne zminimalizowanego okna mogą być zmienione. Flaga ta musi być ustawiona, jeśli współrzędne okna są zmieniane w polu ptMinPosition.
"showCmd" - określa aktualny stan wyświetlania okna
@SW_HIDE | 0 | Ukrywa okno. -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @SW_MAXIMIZE | 3 | Maksymalizuje okno. -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @SW_MINIMIZE | 6 | Minimalizuje okno. -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @SW_RESTORE | 9 | Uaktywnia i wyświetla okno. W przypadku, gdy okno jest zminimalizowane lub zmaksymalizowane, system przywraca je do pierwotnego rozmiaru i położenia. -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @SW_SHOW | 5 | Uaktywnia okno i wyświetla je w swojej obecnej wielkości i położeniu. -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @SW_SHOWMAXIMIZED | 3 | Uaktywnia okno i wyświetla je jako zmaksymalizowane. -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @SW_SHOWMINIMIZED | 2 | Uaktywnia okno i wyświetla je jako zminimalizowane. -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @SW_SHOWMINNOACTIVE | 7 | Wyświetla okno jako zminimalizowane. W odróżnieniu od @SW_SHOWMINIMIZED okno nie jest uaktywniane. -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @SW_SHOWNA | 8 | Wyświetla okno w swojej obecnej wielkości i położeniu. W odróżnieniu od @SW_SHOW okno nie jest uaktywniane. -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @SW_SHOWNOACTIVATE | 4 | Wyświetla okno w swojej najnowszyej wielkości i położeniu. Wartość ta jest podobna do @SW_SHOWNORMAL, z wyjątkiem tego, że okno nie jest aktywne. -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @SW_SHOWNORMAL | 1 | Uaktywnia i wyświetla okno. W przypadku, gdy okno jest zminimalizowane lub zmaksymalizowane, system przywraca je do swojego pierwotnego rozmiaru i położenia.
"ptMinPosition" - Określa współrzędne lewego górnego narożnika okna, gdy okno jest zminimalizowane. Pole jest 2-elementową tablicą.
"ptMaxPosition" - Określa współrzędne lewego górnego narożnika okna, gdy okno jest zmaksymalizowane. Pole jest 2-elementową tablicą.
"rcNormalPosition" - Określa współrzędne domyślne narożników okna (lewy-górny, prawy-dolny). Pole jest 4-elementową tablicą.
_WinAPI_SetWindowPlacement
edytuj#include <WinAPI.au3> _WinAPI_SetWindowPlacement ( $hWnd, $tWindowPlacement )
Funkcja ustawia wielkość i współrzędne okna za pomocą struktury $tagWINDOWPLACEMENT. Zwraca True gdy sukces, Lub False gdy wystąpił błąd. Szczegółowe informacje o błędzie można uzyskać wywołując funkcję _WinAPI_GetLastError().
$hWnd - uchwyt do okna
$tWindowPlacement - struktura z danymi okna. Znaczenie pól struktury jak dla _WinAPI_GetWindowPlacement.
Przykład:
#include <WinAPI.au3>
Run("notepad.exe") ;uruchomienie notatnika
$hWnd = WinWait("[CLASS:Notepad]") ;oczekiwanie na otwarcie okna notatnika i odczyt uchwytu do niego
WinMove($hWnd, "", 256, 256, 400, 400) ;przesunięcie i zmiana rozmiarów okna
Sleep(1000)
WinSetState($hWnd, "", @SW_MINIMIZE) ;zminimalizowanie okna
Sleep(1000)
$tRET = _WinAPI_GetWindowPlacement($hWnd) ;odczyt do struktury typu $stWindowPlacement danych o umiejscowieniu okna
If @error = 0 Then
;formatowanie danych zodczytanych ze struktury $tagWindowPlacement
$sMsg = "Pola struktury $tagWindowPlacement:" & @CRLF & "-----------------------------------------------" & @CRLF
$sMsg &= "length = " & $tRET.length & " bajty" & @CRLF
$sMsg &= "flags = " & $tRET.flags & @CRLF
$sMsg &= "showCmd = " & $tRET.showCmd & @CRLF & @CRLF
$sMsg &= "ptMinPosition:" & @CRLF
$sMsg &= @TAB & "MinX = " & $tRET.ptMinPosition(1) & @CRLF
$sMsg &= @TAB & "MinY = " & $tRET.ptMinPosition(2) & @CRLF & @CRLF
$sMsg &= "ptMaxPosition:" & @CRLF
$sMsg &= @TAB & "MaxX = " & $tRET.ptMaxPosition(1) & @CRLF
$sMsg &= @TAB & "MaxY = " & $tRET.ptMaxPosition(2) & @CRLF & @CRLF
$sMsg &= "rcNormalPosition:" & @CRLF
$sMsg &= @TAB & "left = " & $tRET.rcNormalPosition(1) & @CRLF
$sMsg &= @TAB & "top = " & $tRET.rcNormalPosition(2) & @CRLF
$sMsg &= @TAB & "right = " & $tRET.rcNormalPosition(3) & @CRLF
$sMsg &= @TAB & "bottom = " & $tRET.rcNormalPosition(4)
MsgBox(64, "", $sMsg)
;wprowadzenie za pomocą struktury nowych danych okna notatnika
$tRET.rcNormalPosition(1) = 50 ;lewy
$tRET.rcNormalPosition(2) = 120 ;górny
$tRET.rcNormalPosition(3) = @DesktopWidth - 50 ;prawy
$tRET.rcNormalPosition(4) = @DesktopHeight - 120 ;dolny
$iRET = _WinAPI_SetWindowPlacement($hWnd, $tRET)
WinSetState($hWnd, "", @SW_RESTORE) ;aktywowanie nowych ustawień okna
ControlSetText($hWnd, "", "Edit1", "Pełny sukces!") ;wstawienie tekstu do notatnika
Sleep(3000)
WinKill($hWnd) ;zamknięcie okna notatnika
Else
MsgBox(16, "", "Błąd!")
EndIf
_WinAPI_GetWindowHeight
edytuj#include <WinAPI.au3> _WinAPI_GetWindowHeight($hWnd)
Funkcja zwraca wysokość okna. Jeżeli wystąpił błąd makro @error > 0.
$hWnd - uchwyt do okna
Przykład:
#include <WinAPI.au3>
Local $hwnd, $tRect
$hwnd = GUICreate("")
GUISetState()
$h = _WinAPI_GetWindowHeight($hwnd)
MsgBox(4096, "Okno:", "Wysokość = " & $h)
_WinAPI_GetWindowWidth
edytuj#include <WinAPI.au3> _WinAPI_GetWindowWidth($hWnd)
Funkcja zwraca szerokość okna. Jeżeli wystąpił błąd makro @error > 0.
$hWnd - uchwyt do okna
Przykład:
#include <WinAPI.au3>
Local $hwnd, $tRect
$hwnd = GUICreate("")
GUISetState()
$h = _WinAPI_GetWindowWidth($hwnd)
MsgBox(4096, "Okno:", "Szerokość = " & $h)
_WinAPI_SetFont
edytuj#include <WinAPI.au3> _WinAPI_SetFont($hWnd, $hFont [, $fRedraw = True])
Funkcja ustawia czcionkę w oknie o podanym uchwycie. Nie zwraca żadnej wartości.
$hWnd - uchwyt do okna
$hFont - uchwyt do czcionki
$fRedraw - określa czy okno ma być odświeżona w momencie wywołania funkcji, True (domyślnie) - tak, False - nie.
Przykład:
#include <GuiListBox.au3>
#include <GuiButton.au3>
#include <FontConstants.au3>
$hGUI = GUICreate(@ScriptName, 320, 120)
$hBtn1 = _GUICtrlButton_Create($hGUI, "Przycisk 1", 10, 10, 300, 34)
$hBtn2 = _GUICtrlButton_Create($hGUI, "Przycisk 2", 10, 60, 300, 34)
;definiowanie czcionek
$hFont1 = _WinAPI_CreateFont(30, 0, 0, 0, 400, False, False, False, $DEFAULT_CHARSET, _
$OUT_DEFAULT_PRECIS, $CLIP_DEFAULT_PRECIS, $DEFAULT_QUALITY, 0, 'Comic Sans MS')
$hFont2 = _WinAPI_CreateFont(15, 0, 0, 0, 700)
;ustawienie czcionek
_WinAPI_SetFont($hBtn1, $hFont1)
_WinAPI_SetFont($hBtn2, $hFont2)
GUISetState()
Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE
;zwolnienie zasobów
_WinAPI_DeleteObject($hFont1)
_WinAPI_DeleteObject($hFont2)
_WinAPI_GetLayeredWindowAttributes
edytuj#include <WinAPI.au3> _WinAPI_GetLayeredWindowAttributes($hWnd, ByRef $i_transcolor, ByRef $Transparency [, $asColorRef = False])
Funkcja odczytuje atrybuty warstwy okna. Gdy sukces zwraca:
0 - nic nie ustawiono 1 - ustawiony kolor przezroczysty 2 - ustawiona przezroczystość okna 3 - ustawione oba parametry
Jeżeli wystąpił błąd zwraca 0, a makro @error zawiera kod błędu.
$hWnd - uchwyt do okna
$i_transcolor - zmienna w której przez referencję funkcja zapisuje kolor przezroczysty
$Transparency - zmienna w której przez referencję funkcja zapisuje stopień przezroczystości okna
$asColorRef - określa format kodu koloru zwracany w $i_transcolor, True - format 0x00bbggrr, False (domyślnie) - format RGB
UWAGA: Wartość 0 zwrócona przez funkcję oznacza błąd tylko wtedy, gdy jednocześnie makro @error ma wartość większą od zera.
_WinAPI_SetLayeredWindowAttributes
edytuj#include <WinAPI.au3> _WinAPI_SetLayeredWindowAttributes($hWnd, $i_transcolor [, $Transparency = 255 [, $dwFlags = 0x03 [, $isColorRef = False]]])
Funkcja ustawia atrybuty warstwy okna. Zwraca 1 gdy sukces, lub 0 gdy wystąpił błąd (makro @error = 4 - działanie funkcji nie powiodło się, @extended - dodatkowe dane o przyczynach błędu).
$hWnd - uchwyt do okna
$i_transcolor - kod koloru przezroczystego w formacie RGB (domyślnie) lub 0x00bbggrr, w zależności od parametru $isColorRef (-1 lub Default - kolor domyślny)
$Transparency - stopień przezroczystości okna, 0 - całkowicie przezroczyste, 255 (0xff) - całkowicie nieprzezroczyste
$dwFlags - flaga określająca jakie własności należy ustawić: 1 - ustawić kolor przezroczysty, 2 - ustawić przezroczystość okna, 3 - ustawić oba parametry (domyślne)
$isColorRef - określa format kodu koloru w $i_transcolor, True - format 0x00bbggrr, False (domyślnie) - format RGB
Przykład:
#include <GUIConstantsEx.au3>
#include <WindowsConstants.au3>
#include <WinAPI.au3>
Local $transcolor, $alpha
;tworzenie okna demonstracyjnego, warstwowego (styl $WS_EX_LAYERED)
$gui = GUICreate("Przezroczystość", 400, 400, -1, -1, -1, $WS_EX_LAYERED)
GUISetBkColor(0xABCDEF) ;kolor tła GUI
GUICtrlCreateLabel("To jest okno demonstracyjne", 100, 150)
;początkowa przezroczystość okna =0, domyślny kolor przezroczysty
_WinAPI_SetLayeredWindowAttributes($gui, -1)
GUISetState()
;tworzenie okna kontrolnego
$guicontrol = GUICreate("Test WinAPI", 300, 250, 100, 100)
$checkTrans = GUICtrlCreateCheckbox("Kolor tła przezroczysty", 10, 10)
GUICtrlCreateLabel("Suwak przezroczystości okna", 10, 50)
$slidTrans = GUICtrlCreateSlider(10, 70, 200, 30) ;suwak przezroczystości
GUICtrlSetLimit($slidTrans, 255, 0)
GUICtrlSetData(-1, 255)
$Butt = GUICtrlCreateButton("Info", 10, 150, 40) ;przycisk informacji
GUISetState()
Do
$extMsg = GUIGetMsg(1)
$msg = $extMsg[0]
Switch $extMsg[1]
Case $guicontrol
Select
Case $msg = $GUI_EVENT_CLOSE
Exit
Case $msg = $checkTrans Or $msg = $slidTrans
If GUICtrlRead($checkTrans) = $GUI_CHECKED Then
;tło przezroczyste (kolor 0xABCDEF)
_WinAPI_SetLayeredWindowAttributes($gui, 0xABCDEF, GUICtrlRead($slidTrans))
Else
;bez przezroczystego tła
_WinAPI_SetLayeredWindowAttributes($gui, -1, GUICtrlRead($slidTrans))
EndIf
Case $msg = $Butt
$info=_WinAPI_GetLayeredWindowAttributes($gui, $transcolor, $alpha)
MsgBox(0, "Info", "Kolor przezroczysty: " & Hex($transcolor) & @LF & _
"Stopień przezroczystości: " & $alpha & @LF & _
"Kod ustawień: " & $info)
EndSelect
Case $gui
If $msg = $GUI_EVENT_CLOSE Then Exit
EndSwitch
Until 0
_WinAPI_UpdateLayeredWindow
edytuj#include <WinAPI.au3> _WinAPI_UpdateLayeredWindow($hWnd, $hDCDest, $pPTDest, $pSize, $hDCSrce, $pPTSrce, $iRGB, $pBlend, $iFlags)
Funkcja aktualizacje położenie, wielkość, kształt, treść i przezroczystość okna warstwowego. Zwraca True gdy sukces, lub False gdy wystąpił błąd.
$hWnd - uchwyt do warstwowego okna. Warstwowe okno jest tworzone przez użycie rozszerzonego stylu $WS_EX_LAYERED.
$hDCDest - uchwyt do kontekstu urządzenie na ekranie.
$pPTDest - wskaźnik do struktury $tagPOINT, która określa nową pozycję warstwowego okna. Wartość 0 oznacza, że pozycja okna nie zmienia się.
$pSize - wskaźnik do struktury $tagSIZE, która określa nowy rozmiar warstwowego okna. Wartość 0 oznacza, że rozmiar okna nie zmienia się.
$hDCSrce - uchwyt kontekstu urządzenia na powierzchni, która zawiera warstwowe okno. Uchwyt ten może być uzyskać wywołując funkcję _WinAPI_CreateCompatibleDC.
$pPTSrce - wskaźnik do struktury $tagPOINT, która określa położenie warstwy w kontekście urządzenia.
$iRGB - kod koloru stosowanego przy komponowaniu warstwowego okna.
$pBlend - wskaźnik do struktury $tagBLENDFUNCTION, która określa wartość przezroczystości stosowanej przy komponowania warstwowego okna.
$iFlags - parametr ten może być jedna z następujących wartości:
$ULW_ALPHA - użyj $tblend jako funkcji mieszania $ULW_COLORKEY - użyj $iRGB jako kolor przezroczystości $ULW_OPAQUE - rysowanie nieprzezroczystego warstwowego okna
Przykład (należy przygotować bitmapy tła okna):
#include<WindowsConstants.au3>
#include<GDIPlus.au3>
HotKeySet("{ESC}","_exit_")
_GDIPlus_Startup()
;wczytanie bitmap tła okna
Global $sGUI=_GDIPlus_ImageLoadFromFile('1.jpg')
Global $subGUI=_GDIPlus_ImageLoadFromFile('2.jpg')
$hGUI=GUICreate("", 493, 900, -1, 200, -1, $WS_EX_LAYERED)
GUISetState()
SetBitmap($hGUI,$sGUI,150)
Sleep(2000)
SetBitmap($hGUI,$subGUI,255)
Sleep(1000)
;tworzenie okna potomnego
$sb_GUI = GUICreate("", 400, 600, 50, 30, $WS_POPUP, BitOR($WS_EX_MDICHILD, $WS_EX_LAYERED), $hGUI)
GUISetBkColor(0x666666, $sb_GUI)
$listview = GUICtrlCreateListView("col1 |col2|col3 ", 10, 10, 380, 585)
GUICtrlSetBkColor(-1, 0x666666)
GUICtrlSetColor(-1, 0xF0F0F0)
;ustawienie koloru przezroczystego
_WinAPI_SetLayeredWindowAttributes($sb_GUI, 0x666666)
For $i = 0 To 100 ;tworzenie listy testowej
GUICtrlCreateListViewItem("Item" & Random(1, 100, 1) & "|" & "Item" & Random(1, 100, 1) & _
"|" & "Item" & Random(1, 100, 1), $listview)
Next
GUISetState(@SW_SHOW, $sb_GUI) ;wyświetlenie okna potomnego
While 1
Sleep(30)
WEnd
Func _exit_()
_GDIPlus_ImageDispose($sGUI)
_GDIPlus_ImageDispose($subGUI)
_GDIPlus_Shutdown()
Exit
EndFunc
;funkcja wstawia bitmapę jako tło okna, jednocześnie można zmieniać przezroczystość okna
Func SetBitmap($hGUI,$hImage,$iOpacity)
Local $hScrDC,$hMemDC,$hBitmap,$hOld,$pSize,$tSize,$pSource,$tSource,$pBlend,$tBlend
$hScrDC=_WinAPI_GetDC(0)
$hMemDC=_WinAPI_CreateCompatibleDC($hScrDC)
$hBitmap=_GDIPlus_BitmapCreateHBITMAPFromBitmap($hImage)
$hOld=_WinAPI_SelectObject($hMemDC,$hBitmap)
$tSize=DllStructCreate($tagSIZE)
$pSize=DllStructGetPtr($tSize)
DllStructSetData($tSize,"X",_GDIPlus_ImageGetWidth($hImage))
DllStructSetData($tSize,"Y",_GDIPlus_ImageGetHeight($hImage))
$tSource=DllStructCreate($tagPOINT)
$pSource=DllStructGetPtr($tSource)
$tBlend=DllStructCreate($tagBLENDFUNCTION)
$pBlend=DllStructGetPtr($tBlend)
DllStructSetData($tBlend,"Alpha",$iOpacity)
DllStructSetData($tBlend,"Format", 1)
_WinAPI_UpdateLayeredWindow($hGUI,$hScrDC,0,$pSize,$hMemDC,$pSource,0,$pBlend,$ULW_ALPHA)
;zwolnienie zasobów
_WinAPI_ReleaseDC(0,$hScrDC)
_WinAPI_SelectObject($hMemDC,$hOld)
_WinAPI_DeleteObject($hBitmap)
_WinAPI_DeleteDC($hMemDC)
EndFunc ;SetBitmap
_WinAPI_MoveWindow
edytuj#include <WinAPI.au3> _WinAPI_MoveWindow($hWnd, $iX, $iY, $iWidth, $iHeight [, $fRepaint = True])
Funkcja zmienia położenie i rozmiar okna. Zwraca True gdy sukces, lub False gdy wystąpił błąd.
$hWnd - uchwyt do okna.
$iX i $iY - nowe współrzędne lewego górnego narożnika okna.
$iCX i $iCY - nowa szerokość i wysokość okna.
$fRepaint - True - okno potomne jest przerysowywane po przesunięciu lub zmianie wymiarów (wartość domyślna), False - okno nie jest przerysowane.
Przykład:
#include <WinAPI.au3>
#include <Constants.au3>
Run('notepad.exe')
Sleep(2000)
$hGui = WinWait("[CLASS:Notepad]", "", 5)
$aOld = WinGetPos($hGUI)
Sleep(2000)
_WinAPI_MoveWindow ($hGui, 350, 200, 200, 200)
;przesuwanie okna
$a = WinGetPos($hGui)
For $i=0 To 300 Step 0.01
_WinAPI_MoveWindow ($hGui, $a[1]+$i, $a[1]+$i/2, $a[2], $a[3])
Next
;powiększanie okna
$a = WinGetPos($hGui)
For $i=0 To 500 Step 0.01
_WinAPI_MoveWindow ($hGui, $a[0], $a[1], $a[2]+$i, $a[3]+$i)
Next
;zmniejszanie okna bez zmiany położenia jego środka
$a = WinGetPos($hGui)
For $i=0 To 350 Step 0.01
_WinAPI_MoveWindow ($hGui, $a[0]+$i, $a[1]+$i, $a[2]-2*$i, $a[3]-2*$i)
Next
Sleep(1000)
;przywrócenie pierwotnego położenia i rozmiarów okna
_WinAPI_MoveWindow ($hGui, $aOld[0], $aOld[1], $aOld[2], $aOld[3])
Przykład 2 (z oknem potomnym):
#include <WinAPI.au3>
#include<WindowsConstants.au3>
Local $iX = 50, $iY = 100, $iCX = 300, $iCY = 240, $style = BitOR($WS_CHILD, $WS_VSCROLL)
$h = GUICreate ( "Test" , 650 , 600, 300, 300 )
GUICtrlCreateButton(' TEST ', 250, 360, 120, 28)
$ch=GUICreate("", $iCX, $iCY, $iX, $iY, $style, -1, $h)
GUICtrlCreateButton(' TEST ', 50, 60, 100, 28)
GUISetBkColor(0xff0000)
GUISetState(@SW_SHOW ,$h)
GUISetState(@SW_SHOW ,$ch)
Sleep(1000)
For $i=0 To 250
Sleep(1)
$iX += 1
$iY += 0.5
_WinAPI_MoveWindow ($ch, $iX, $iY, $iCX, $iCY)
Next
Sleep(3000)
_WinAPI_GetDesktopWindow
edytuj#include <WinAPI.au3> _WinAPI_GetDesktopWindow()
Funkcja zwraca uchwyt do okna desktopu.
Przykład:
#include <WinAPI.au3>
$win = _WinAPI_GetDesktopWindow()
MsgBox(0, "Uchwyt desktopu:", $win)
_WinAPI_GetWindow
edytuj#include <WinAPI.au3> _WinAPI_GetWindow($hWnd, $iCmd)
Funkcja zwraca uchwyt do okna pozostającego w określonym związku z danym oknem. Zwraca 0 gdy wystąpił błąd lub nie istnieje okno o zdefiniowanym związku.
$hWnd - uchwyt do okna
$iCmd - parametr określa zależność między określonym oknem, a oknem, którego uchwyt ma być zwrócony:
<Constants.au3>| | Opis --------------------------------------------------------------------------------------------------------- $GW_CHILD | 5 | aktywne okno podrzędne $GW_HWNDFIRST | 0 | najwyżej stojące okno wg kolejności nakładania Z, posiadające to samo okno nadrzędne $GW_HWNDLAST | 1 | najniżej stojące okno wg kolejności nakładania Z, posiadające to samo okno nadrzędne $GW_HWNDNEXT | 2 | okno będące bezpośrednio poniżej danego okna wg kolejności nakładania Z $GW_HWNDPREV | 3 | okno będące bezpośrednio powyżej danego okna wg kolejności nakładania Z $GW_OWNER | 4 | okno nadrzędne danego okna
_WinAPI_GetForegroundWindow
edytuj#include <WinAPI.au3> _WinAPI_GetForegroundWindow()
Funkcja zwraca uchwyt do aktywnego okna, lub 0 gdy wystąpił błąd.
Przykład:
#include <WinAPI.au3>
MsgBox(0, "_WinAPI_GetForegroundWindow", _
"Uchwyt do aktywnego okna: " & _WinAPI_GetForegroundWindow())
_WinAPI_GetParent
edytuj#include <WinAPI.au3> _WinAPI_GetParent($hWnd)
Funkcja zwraca uchwyt do okna nadrzędnego, lub 0 gdy wystąpił błąd (pełne informacje o błędzie zwraca funkcja _WinAPI_GetLastError()).
$hWnd - uchwyt do okna
_WinAPI_SetParent
edytuj#include <WinAPI.au3> _WinAPI_SetParent ( $hWndChild, $hWndParent )
Funkcja zmienia okno nadrzędne dla podanego okna potomnego. Zwraca uchwyt do poprzedniego okna nadrzędnego, lub 0 gdy wystąpił błąd (pełne informacje o błędzie zwraca funkcja _WinAPI_GetLastError()).
$hWndChild - uchwyt do okna potomnego.
$hWndParent - uchwyt do nowego okna nadrzędnego, jeżeli =0 to nowym oknem nadrzędnym będzie pulpit.
#include <GUIConstantsEx.au3>
#include <WinAPI.au3>
#include <WindowsConstants.au3>
;tworzenie dwóch okien GUI
$hGUI1 = GUICreate("GUI 1", 400, 400, 200, 100)
$hGUI2 = GUICreate("GUI 2", 400, 400, 1200, 200)
;tworzenie okna potomnego w oknie GUI 1
$hChild = GUICreate("Okno potomne", 200, 200, 50, 50, BitOR($WS_CHILD, $WS_CAPTION), -1, $hGUI1)
;wyświetlenie okien
GUISetState(@SW_SHOW, $hGUI1)
GUISetState(@SW_SHOW, $hChild)
GUISetState(@SW_SHOW, $hGUI2)
MsgBox(64,"","Okno potomne do GUI 2")
_WinAPI_SetParent($hChild, $hGUI2) ;zmiana okna nadrzędnego
MsgBox(64,"","Okno potomne do GUI 1")
_WinAPI_SetParent($hChild, $hGUI1) ;zmiana okna nadrzędnego
Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE
_WinAPI_GetAncestor
edytuj#include <WinAPI.au3> _WinAPI_GetAncestor($hWnd [, $iFlags = 1])
Funkcja zwraca uchwyt okna nadrzędnego, lub 0 gdy wystąpił błąd.
$hWnd - uchwyt do okna, którego przodka chcemy uzyskać, jeżeli jest to uchwyt do pulpitu to funkcja zwróci 0
$iFlags - określa jakiego okna uchwyt chcemy uzyskać:
WindowsConstants.au3 | | Opis
---------------------------------------------------------------------------------------
$GA_PARENT | 1 | zwraca uchwyt do rodzica obiektu przekazanego jako argument,
| | jeżeli pierwszym w kolejności "rodzicem" nie jest
| | okno programu lecz inny obiekt, to zwrócony zostanie
| | uchwyt do tego obiektu, a nie do okna programu
---------------------------------------------------------------------------------------
$GA_ROOT | 2 | zwraca uchwyt do okna obiektu przekazanego jako argument,
| | poprzez przejście przez kolejnych "rodziców" (parent)
| | wskazanego obiektu, aż natrafi na okno
---------------------------------------------------------------------------------------
$GA_ROOTOWNER | 3 |
---------------------------------------------------------------------------------------
Przykład:
#include <WinAPI.au3>
#include <WindowsConstants.au3>
$hWnd = GUICreate("TEST")
$hParent = _WinAPI_GetAncestor($hWnd, $GA_PARENT)
MsgBox(0, "GetAncestor dla " & $hWnd, _
'Parent:' & @TAB & @TAB & $hParent & @CRLF & _
'Root:' & @tab & @tab & _WinAPI_GetAncestor($hWnd, $GA_ROOT) & @CRLF & _
'Root Owner:' & @tab & _WinAPI_GetAncestor($hWnd, $GA_ROOTOWNER))
_WinAPI_GetWindowLong
edytuj#include <WinAPI.au3> _WinAPI_GetWindowLong($hWnd, $iIndex)
Funkcja zwraca informacje o określonym oknie. Jeżeli wystąpi błąd makro @error zwraca kod błędu.
$hWnd - uchwyt do okna
$iIndex - rodzaj zwracanej informacji:
<Constants.au3> | | Opis
------------------------------------------------------------------------------------------------
$GWL_EXSTYLE |-20 | rozszerzony styl okna
$GWL_HINSTANCE | -6 | uchwyt do instancji programu
$GWL_HWNDPARENT | -8 | uchwyt do okna nadrzędnego (jeśli dane okno ma rodzica)
$GWL_ID |-12 | identyfikator okna potomnego
$GWL_STYLE |-16 | styl okna
$GWL_USERDATA |-21 | 32-bitowe dane użytkownika powiązane z oknem. Takie dane są przeznaczone
| | do użycia przez program, który utworzył okno. Na początku ta wartość =0.
$GWL_WNDPROC | -4 | adres procedury okna
_WinAPI_SetWindowLong
edytuj#include <WinAPI.au3> _WinAPI_SetWindowLong($hWnd, $iIndex, $iValue)
Funkcja ustawia parametry okna o określonym uchwycie. Zwraca poprzednią wartość ustawianego parametru, lub 0 gdy wystąpił błąd.
$hWnd - uchwyt do okna
$iIndex - rodzaj ustawianej informacji (jak dla _WinAPI_GetWindowLong)
Przykłąd:
#include <GUIConstantsEx.au3>
#include <Constants.au3>
#include <WindowsConstants.au3>
#include <WinAPI.au3>
$hGui = GUICreate('_WinAPI_SetWindowLong', 250, 260)
$iButton = GUICtrlCreateButton('Zmiana stylu okna', 10, 10, 120, 28)
$iExStyle = $WS_EX_TOOLWINDOW
GUISetState()
Do
Switch GUIGetMsg()
Case $iButton
$iOldExStyle = _WinAPI_SetWindowLong($hGui, $GWL_EXSTYLE, $iExStyle)
$iExStyle = $iOldExStyle
GUISetState(@SW_HIDE)
GUISetState(@SW_SHOW)
Case $GUI_EVENT_CLOSE
Exit
EndSwitch
Until 0
_WinAPI_GetWindowText
edytuj#include <WinAPI.au3> _WinAPI_GetWindowText($hWnd)
Funkcja zwraca tytuł z belki okna lub z kontrolki o podanym uchwycie. Jeżeli wystąpił błąd ustawiane jest makro @error.
$hWnd - uchwyt do okna (kontrolki)
Przykład:
#include <WinAPI.au3>
$hWin = WinGetHandle("[ACTIVE]")
$hGui = GUICreate('Okno testowe')
$iButton = GUICtrlCreateButton('Przycisk', 10, 10)
GUISetState()
MsgBox(0, 'Wyniki:', _
_WinAPI_GetWindowText($hWin) &@CRLF& _
_WinAPI_GetWindowText($hGui) &@CRLF& _
_WinAPI_GetWindowText(GUICtrlGetHandle($iButton)))
_WinAPI_SetWindowText
edytuj#include <WinAPI.au3> _WinAPI_SetWindowText($hWnd, $sText)
Funkcja wstawia tytuł na belce okna lub kontrolce o podanym uchwycie. Zwraca True gdy sukces, lub False gdy wystąpił błąd.
$hWnd - uchwyt do okna (kontrolki)
$sText - wstawiany tekst tytułu okna lub kontrolki
Przykład:
#include <WinAPI.au3>
#include <GUIConstantsEx.au3>
$hGui = GUICreate('GUI testowy', 350, 260)
$iButton = GUICtrlCreateButton('Przycisk', 10, 10, 160, 28)
$hButton = GUICtrlGetHandle(-1)
GUISetState()
Do
Switch GUIGetMsg()
Case $iButton
If _WinAPI_GetWindowText($hButton) = "Przycisk" Then
_WinAPI_SetWindowText($hButton, "Klawisz")
Else
_WinAPI_SetWindowText($hButton, "Przycisk")
EndIf
$txt = _WinAPI_GetWindowText($hGui) & "!"
_WinAPI_SetWindowText($hGui, $txt)
Case $GUI_EVENT_CLOSE
Exit
EndSwitch
Until False
_WinAPI_GetClassName
edytuj#include <WinAPI.au3> _WinAPI_GetClassName($hWnd)
Funkcja zwraca nazwę klasy, do której należy okno. Jeżeli wystąpi błąd ustawiane jest makro @error.
$hWnd - uchwyt do okna
Przykład:
#include <WinAPI.au3>
$hDesktop = _WinAPI_GetDesktopWindow() ;uchwyt do desktopu
MsgBox(0, "Klasa okna desktopu", 'ClassName = "' & _WinAPI_GetClassName($hDesktop) & '"')
$hwnd = GUICreate("test") ;uchwyt do okna skryptu
$iButton = GUICtrlCreateButton('TEST', 10, 10, 120, 28)
MsgBox(0, "Klasa okna skryptu", 'ClassName = "' & _WinAPI_GetClassName($hwnd) & '"')
_WinAPI_SetWindowPos
edytuj#include <WinAPI.au3> _WinAPI_SetWindowPos($hWnd, $hAfter, $iX, $iY, $iCX, $iCY, $iFlags)
Funkcja zmienia rozmiar, położenie i Z-kolejność okna dziecka, pop-up, lub okna najwyższego poziomu. Zwraca True gdy sukces, lub False gdy wystąpił błąd.
$hWnd - uchwyt do okna.
$hAfter - uchwyt do okna poprzedzającego dane okno w osi Z (znajdującego się bezpośrednio nad nim), lub jedna z poniższych wartości:
Wg Constants.au3 | | Opis
---------------------------------------------------------------------------------------------------------
$HWND_BOTTOM | 1 | Umieszcza okno na spodzie Z rzędu.
---------------------------------------------------------------------------------------------------------
$HWND_NOTOPMOST | -2 | Umieszcza okno poniżej wszystkich okien najwyższego poziomu. Ustawienie tej
| | flagi niczego nie zmienia, jeśli okno nie jest oknem najwyższego poziomu.
---------------------------------------------------------------------------------------------------------
$HWND_TOP | 0 | Umieszcza okno na wierzchu Z rzędu.
---------------------------------------------------------------------------------------------------------
$HWND_TOPMOST | -1 | Umieszcza okno powyżej wszystkich okien, które nie są oknami najwyższego poziomu.
| | Okno utrzymuje swój stan okna najwyższego poziomu, nawet gdy jest dezaktywowane.
---------------------------------------------------------------------------------------------------------
$iX i $iY - nowe współrzędne lewego górnego narożnika okna.
$iCX i $iCY - nowa szerokość i wysokość okna.
$iFlags - flaga:
Wg Constants.au3 | Wartość| Opis
-------------------------------------------------------------------------------------------------------------
$SWP_DRAWFRAME | 0x0020 | Rysuje ramkę wokół okna.
-------------------------------------------------------------------------------------------------------------
$SWP_FRAMECHANGED | 0x0020 | Zmienia nowe style ramki używając funkcji _SetWindowLong. Wysyła komunikat
| | WM_NCCALCSIZE do okna, nawet jeśli jego rozmiar nie zostanie zmieniony.
| | Jeśli ta flaga nie jest ustawiona, komunikat WM_NCCALCSIZE jest wysyłany
| | tylko podczas zmiany rozmiaru okna.
-------------------------------------------------------------------------------------------------------------
$SWP_HIDEWINDOW | 0x0080 | Ukrywa okno.
-------------------------------------------------------------------------------------------------------------
$SWP_NOACTIVATE | 0x0010 | Nie pozwala na aktywację okna.
-------------------------------------------------------------------------------------------------------------
$SWP_NOCOPYBITS | 0x0100 | Nie kopiuje zawartości obszaru klienta. Jeśli ta flaga nie jest ustawiona,
| | poprawna treść obszaru klienta jest zapisywana i kopiowana z powrotem
| | do obszaru klienta po zmianie pozycji lub rozmiaru okna.
-------------------------------------------------------------------------------------------------------------
$SWP_NOMOVE | 0x0002 | Zachowuje obecną pozycję (ignoruje wartości argumentów $iX i $iY).
-------------------------------------------------------------------------------------------------------------
$SWP_NOOWNERZORDER | 0x0200 | Nie zmienia pozycji okna w osi Z.
$SWP_NOREPOSITION | |
-------------------------------------------------------------------------------------------------------------
$SWP_NOREDRAW | 0x0008 | Nie odrysowuje okna. Jeśli ta flaga jest ustawiona, okno nie jest odmalowywane.
| | Kiedy ta flaga jest ustawiona, program musi jawnie odświeżyć lub odrysować
| | określone części danego okna oraz okna nadrzędnego.
-------------------------------------------------------------------------------------------------------------
$SWP_NOSENDCHANGING| 0x0400 | Zapobiega przechwytywaniu komunikatu WM_WINDOWPOSCHANGING przez dane okno.
-------------------------------------------------------------------------------------------------------------
$SWP_NOSIZE | 0x0001 | Zachowuje obecny rozmiar okna (ignoruje argumenty $iCX i $iCY).
-------------------------------------------------------------------------------------------------------------
$SWP_NOZORDER | 0x0004 | Zachowuje obecną kolejność elementów w osi Z (ignoruje argument $hAfter).
-------------------------------------------------------------------------------------------------------------
$SWP_SHOWWINDOW | 0x0040 | Wyświetla dane okno.
-------------------------------------------------------------------------------------------------------------
Przykład:
#include <WinAPI.au3>
#include <Constants.au3>
$hGui2 = GUICreate('Okno 1', 550, 350, 500, 200)
GUISetState()
Sleep(1000)
$hGui1 = GUICreate('Okno 2', 350, 200, 100, 100)
$iButton = GUICtrlCreateButton('TEST', 10, 10, 120, 28)
GUISetState()
Sleep(1000)
;przesuwanie okna (okno 1 za oknem 2)
$a = WinGetPos($hGui1)
For $i=0 To 300 Step 0.1
_WinAPI_SetWindowPos ($hGui1, $hGui2, $a[1]+$i, $a[1]+$i/2, $a[2], $a[3], $SWP_DRAWFRAME)
Next
;powiększanie okna (okno 1 przed oknem 2)
$a = WinGetPos($hGui1)
For $i=0 To 500 Step 0.1
_WinAPI_SetWindowPos ($hGui1, $HWND_TOP, $a[0], $a[1], $a[2]+$i, $a[3]+$i, $SWP_DRAWFRAME)
Next
;zmniejszanie okna bez zmiany położenia jego środka (okno 1 za oknem 2)
$a = WinGetPos($hGui1)
For $i=0 To 350 Step 0.1
_WinAPI_SetWindowPos ($hGui1, $hGui2, $a[0]+$i, $a[1]+$i, $a[2]-2*$i, $a[3]-2*$i, $SWP_DRAWFRAME)
Next
_WinAPI_WindowFromPoint
edytuj#Include <WinAPI.au3> _WinAPI_WindowFromPoint (ByRef $tPoint)
Funkcja zwraca uchwyt do okna znajdującego się w punkcie o podanych współrzędnych, lub 0 gdy wystąpił błąd.
$tPoint - struktura $tagPOINT zawierająca współrzędne punktu
UWAGA: Funkcja nie zwraca uchwytu do okien ukrytych lub wyłączonych, nawet gdy punkt znajduje się wewnątrz okna.
Przykład:
#include <WinAPI.au3>
HotKeySet("{ESC}", "Close") ;ESC - koniec programu
$tStruct = DllStructCreate($tagPOINT) ;tworzenie struktury
Do
ToolTip("")
;odczyt współrzednych kursora i zapis do struktury
DllStructSetData($tStruct, "x", MouseGetPos(0))
DllStructSetData($tStruct, "y", MouseGetPos(1))
;odczyt uchwytu do okna pod kursorem
$hWnd = _WinAPI_WindowFromPoint($tStruct)
ToolTip($hWnd) ;wyświetlenie uchwytu do okna
Sleep(100)
Until 0
_WinAPI_GetFocus
edytuj#include <WinAPI.au3> _WinAPI_GetFocus()
Funkcja zwraca uchwyt do okna (kontrolki) z ustawionym focus'em, lub 0 gdy wystąpił błąd.
UWAGA:
Focus (z ang. skupienie) jest to jeden ze stanów elementu graficznego interfejsu użytkownika. Wszelkie zdarzenia związane z naciskaniem klawiszy przez użytkownika zostaną skierowane właśnie do tego elementu (np.kontrolki).
Zazwyczaj w oknach można przenosić focus na następny element za pomocą klawisza TAB (i SHIFT-TAB).
Focus jest najczęściej odpowiednio odwzorowany w wyglądzie elementu, np. przycisk dostaje dodatkowe obramowanie, w polu edycyjnym pojawia się migający kursor, itp.
_WinAPI_SetFocus
edytuj#include <WinAPI.au3> _WinAPI_SetFocus($hWnd)
Funkcja ustawia focus dla danego okna (kontrolki). Zwraca uchwyt do okna (kontrolki), które poprzednio miało ustawiony focus, lub 0 gdy wystąpił błąd.
$hWnd - uchwyt do okna (kontrolki), dla której ustawiamy focus
Przykład:
- include <WinAPI.au3>
- include <GUIConstantsEx.au3>
$hGui = GUICreate("Focus - okno testowe", 370, 80, -1, 300) $hInput1 = GUICtrlCreateInput("Pole 1", 12, 28, 121, 21) $hInput2 = GUICtrlCreateInput("Pole 2", 232, 28, 121, 21) $hButton1 = GUICtrlCreateButton("<", 148, 24, 27, 25) $hButton2 = GUICtrlCreateButton(">", 184, 24, 27, 25) GUISetState(@SW_SHOW)
Sleep(2000) $hFocus = _WinAPI_GetFocus() ;przycisk z focusem MsgBox(0, "Focus na kontrolce:", WinGetTitle($hFocus))
While 1
Switch GUIGetMsg()
Case $GUI_EVENT_CLOSE
Exit
Case $hButton1
_WinAPI_SetFocus(GUICtrlGetHandle($hInput1))
Case $hButton2
_WinAPI_SetFocus(GUICtrlGetHandle($hInput2))
EndSwitch
WEnd </syntaxhighlight>
_WinAPI_FlashWindow
edytuj#include <WinAPI.au3> _WinAPI_FlashWindow ( $hWnd [, $bInvert = True] )
Funkcja powoduje pojedyncze mrugnięcie (flash) okna i przycisku na pasku zadań. Zwraca TRUE gdy sukces, lub FALSE gdy wystąpił błąd.
$hWnd - uchwyt do okna, które ma mrugnąć. Okno może być otwarte lub zminimalizowane.
$bInvert - określa sposób zadziałania:
True - powoduje mrugnięcie okna i przycisku na pasku zadań, jeżeli okno jest zminimalizowane mruga przycisk i zmienia barwę
False - okno i przycisk nie mrugają, jeżeli okno jest zminimalizowane przycisk zmienia barwę bez uprzedniego mrugnięcia
Przykład:
#include <GUIConstantsEx.au3>
#include <WinAPI.au3>
$hWnd = GUICreate("_WinAPI_FlashWindow", 200, 200)
$idBtnFlash = GUICtrlCreateButton("Mrugnięcie", 50, 85, 100, 30)
GUISetState(@SW_SHOW)
While 1
$iMsg = GUIGetMsg()
Select
Case $iMsg = $GUI_EVENT_CLOSE
Exit
Case $iMsg = $idBtnFlash
Sleep(2000)
_WinAPI_FlashWindow($hWnd)
EndSelect
WEnd
_WinAPI_FlashWindowEx
edytuj#include <WinAPI.au3> _WinAPI_FlashWindowEx ( $hWnd [, $iFlags = 3 [, $iCount = 3 [, $iTimeout = 0]]] )
Funkcja powoduje mrugnie (flash) okna i przycisku na pasku zadań. Zwraca TRUE gdy sukces, lub FALSE gdy wystąpił błąd.
W stosunku do _WinAPI_FlashWindow posiada większe możliwości konfigurowania.
$hWnd - uchwyt do okna, które ma mrugać. Okno może być otwarte lub zminimalizowane.
$iFlags - tryb działania:
0 - mruganie wyłączone, system przywraca okno do stanu pierwotnego
1 - mruganie okna
2 - mruganie przycisku na pasku zadań
4 - mruganie nieprzerwane, aż do zatrzymania
8 - mruga nieprzerwanie, aż okno wyjdzie na pierwszy plan
$iCount - ilość mrugnięć okna
$iTimeout - czas mrugnięcia w milisekundach, 0 - domyślny czas mrugnięcia kursora
Przykład:
#include <GUIConstantsEx.au3>
#include <WinAPI.au3>
$hWnd = GUICreate("_WinAPI_FlashWindowEx", 200, 200)
$idBtnFlash = GUICtrlCreateButton("Mrugnięcia", 50, 85, 100, 30)
GUISetState(@SW_SHOW)
While 1
$iMsg = GUIGetMsg()
Select
Case $iMsg = $GUI_EVENT_CLOSE
Exit
Case $iMsg = $idBtnFlash
Sleep(1000)
_WinAPI_FlashWindowEx($hWnd, 3, 6)
EndSelect
WEnd
Mysz i klawiatura
edytuj_WinAPI_GetAsyncKeyState
edytuj#include <WinAPI.au3> _WinAPI_GetAsyncKeyState ( $iKey )
Funkcja sprawdza czy został wciśnięty klawisz o podanym kodzie. Zwraca liczbę dwu bajtową w której:
- ustawiony jest najstarszy bit jeżeli dany klawisz jest wciśnięty w momencie wywołania funkcji (wartość -32767)
- ustawiony jest najmłodszy bit jeżeli dany klawisz był wciśnięty po poprzednim wywołaniu funkcji _WinAPI_GetAsyncKeyState (wartość 1, na tym rezultacie nie można jednak w 100% polegać)
- ma wartość 0 gdy klawisz nie był wciśnięty, lub gdy wystąpił błąd
$iKey - kod klawisza (MSDN Library - Virtual-Key Codes
UWAGA:
1. Funkcja rozpoznaje stan klawiszy klawiatury i myszy.
2. Funkcja rozpoznaje tylko klawisze fizyczne, a nie funkcjonalne. Przykładowo lewy klawisz myszy to konstrukcyjnie klawisz z lewej strony urządzenie, a nie klawisz mający funkcję lewego klawisza (w systemie operacyjnym osoba leworęczna można przypisać funkcję lewego klawisza do fizycznego klawisza prawego).
Przykład:
#include <WinAPI.au3>
$iKey = 0x1 ;lewy przycisk myszy
Sleep(2000)
MsgBox(0, "", _WinAPI_GetAsyncKeyState($iKey))
;wyświetli -32767 gdy lewy przycisk myszy był wciśnięty w momencie
;wywołania funkcji, 1 gdy wciśniemy na krótko klawisz przed wywołaniem
;funkcji, 0 gdy w ogóle nie wciśniemy lewego klawisza myszy
_WinAPI_Mouse_Event
edytuj#include <WinAPI.au3> _WinAPI_Mouse_Event($iFlags [, $iX = 0 [, $iY = 0 [, $iData = 0 [, $iExtraInfo = 0]]]])
Funkcja symuluje ruchy myszy, wciskanie jej przycisków i obracanie kółkiem. Nie zwraca żadnej wartości.
$iFlags - flaga określająca rodzaj symulowanej akcji myszy, może być każdą rozsądną kombinacją następujących wartości:
wg Constants.au3 | | opis
------------------------------------------------------------------------------------
$MOUSEEVENTF_ABSOLUTE | 0x8000 | $iX i $iY są współrzędnymi absolutnymi kursora
| | w przeciwnym razie są przesunięciami w danej osi
------------------------------------------------------------------------------------
$MOUSEEVENTF_MOVE | 0x0001 | przesunięcie myszy
------------------------------------------------------------------------------------
$MOUSEEVENTF_LEFTDOWN | 0x0002 | wciśnięty lewy klawisz myszy
------------------------------------------------------------------------------------
$MOUSEEVENTF_LEFTUP | 0x0004 | zwolniony lewy klawisz myszy
------------------------------------------------------------------------------------
$MOUSEEVENTF_RIGHTDOWN | 0x0008 | wciśnięty prawy klawisz myszy
------------------------------------------------------------------------------------
$MOUSEEVENTF_RIGHTUP | 0x0010 | zwolniony prawy klawisz myszy
------------------------------------------------------------------------------------
$MOUSEEVENTF_MIDDLEDOWN | 0x0020 | wciśnięty środkowy klawisz myszy
------------------------------------------------------------------------------------
$MOUSEEVENTF_MIDDLEUP | 0x0040 | zwolniony środkowy klawisz myszy
------------------------------------------------------------------------------------
$MOUSEEVENTF_WHEEL | 0x0800 | obrócone kółko myszy
------------------------------------------------------------------------------------
$MOUSEEVENTF_XDOWN | 0x0080 | wciśnięty X klawisz myszy
------------------------------------------------------------------------------------
$MOUSEEVENTF_XUP | 0x0100 | zwolniony X klawisz myszy
$iX i $iY - nowe współrzędne absolutne kursora myszy ($MOUSEEVENTF_ABSOLUTE) lub przesunięcie kursora w odpowiedniej osi
$iData - jeżeli ustawione $MOUSEEVENTF_WHEEL to jest to wielkość obrotu kółka myszy, wartość dodatnia - obrót do przodu, wartość ujemna - obrót do tyłu, jednostkowy obrót kółka to 120, jeżeli $MOUSEEVENTF_WHEEL nie jest ustawione to powinno być $iData = 0
$iExtraInfo - 32 bitowa wartość związana z myszą
UWAGA: Współrzędne $iX i$iY odnoszą się do wirtualnego ekranu o wymiarach 65535x65535. Aby przeliczyć rzeczywiste współrzędne na wirtualne należy przyjąć: $iX=$x*65535/@DesktopWidth i $y=$y*65535/@DesktopHeight (gdzie $x i $y to rzeczywiste współrzędne ekranowe). Ta sama zasada dotyczy przesunięć przy nie ustawionym $MOUSEEVENTF_ABSOLUTE.
Przykład:
#include <Constants.au3>
#include <WinAPI.au3>
Local $x = 500, $y = 400
;przeliczenie współrzędnych na wirtualny ekran
$iX = $x * 65535 / @DesktopWidth
$iY = $y * 65535 / @DesktopHeight
;przesunięcie myszy
_WinAPI_Mouse_Event(BitOR($MOUSEEVENTF_ABSOLUTE, $MOUSEEVENTF_MOVE), $iX, $iY)
_WinAPI_Mouse_Event($MOUSEEVENTF_RIGHTDOWN) ;wciśnięcie prawego przycisku
_WinAPI_Mouse_Event($MOUSEEVENTF_RIGHTUP) ;zwolnienie prawego przycisku
_WinAPI_GetMousePos
edytuj#include <WinAPI.au3> _WinAPI_GetMousePos([$fToClient = False [, $hWnd = 0]])
Funkcja zwraca bieżącą pozycję kursora myszy w postaci struktury $tagPOINT. Jeżeli wystąpił błąd ustawiane jest makro @error.
$fToClient - False - współrzędne absolutne ekranu, True - współrzędne przestrzeni roboczej okna
$hWnd - uchwyt do okna, tylko dla $fToClient = True
Przykład:
#include <WinAPI.au3>
$hWnd = GUICreate("Okno testowe")
GUISetState()
$tPoint1 = _WinAPI_GetMousePos()
$tPoint2 = _WinAPI_GetMousePos(True, $hWnd)
MsgBox(0, "Położenie kursora myszy", _
"We współrzędnych absolutnych:" & @LF & _
"X = " & DllStructGetData($tPoint1, "X") & @LF & _
"y = " & DllStructGetData($tPoint1, "Y") & @LF & @LF & _
"We współrzędnych okna:" & @lf & _
"x = " & DllStructGetData($tPoint2, "X") & @lf & _
"y = " & DllStructGetData($tPoint2, "Y"))
_WinAPI_GetMousePosX
edytuj#Include <WinAPI.au3> _WinAPI_GetMousePosX ([$fToClient = False [, $hWnd = 0]])
Funkcja zwraca współrzędną poziomą kursora myszy. Jeżeli wystąpił błąd ustawiane jest makro @error.
$fToClient - False - współrzędne absolutne ekranu, True - współrzędne przestrzeni roboczej okna
$hWnd - uchwyt do okna, tylko dla $fToClient = True
_WinAPI_GetMousePosY
edytuj#Include <WinAPI.au3> _WinAPI_GetMousePosY ([$fToClient = False [, $hWnd = 0]])
Funkcja zwraca współrzędną poziomą kursora myszy. Jeżeli wystąpił błąd ustawiane jest makro @error.
$fToClient - False - współrzędne absolutne ekranu, True - współrzędne przestrzeni roboczej okna
$hWnd - uchwyt do okna, tylko dla $fToClient = True
Przykład:
#include <WinAPI.au3>
$hWnd = GUICreate("Okno testowe")
GUISetState()
$x1 = _WinAPI_GetMousePosX()
$x2 = _WinAPI_GetMousePosX(True, $hWnd)
$y1 = _WinAPI_GetMousePosY()
$y2 = _WinAPI_GetMousePosY(True, $hWnd)
MsgBox(0, "Położenie kursora myszy", _
"We współrzędnych absolutnych:" & @LF & _
"X = " & $x1 & @LF & _
"y = " & $y1 & @LF & @LF & _
"We współrzędnych okna:" & @lf & _
"x = " & $x2 & @lf & _
"y = " & $y2)
_WinAPI_EnableWindow
edytuj#include <WinAPI.au3> _WinAPI_EnableWindow ( $hWnd [, $bEnable = True] )
Funkcja blokuje, lub odblokowuje dostęp myszki i klawiatury do określonego okna lub kontrolki. Zwraca True gdy okno (kontrolka) było poprzednio zablokowane, lub Felse gdy było odblokowane.
$hWnd' - uchwyt do okna lub kontrolki
$bEnable - rodzaj operacji, True - odblokowanie, False - blokowanie
Przykład:
#include <GUIConstantsEx.au3>
#include <WinAPI.au3>
$hGUI = GUICreate("_WinAPI_EnableWindow", 400, 300)
$hLab = GUICtrlCreateLabel("", 70, 80,220,70)
GUISetState()
_WinAPI_EnableWindow ( $hGUI, False) ;zablokowanie dostępu do okna
GUICtrlSetData($hLab,"Kursor zablokowany na 5 sekund")
Sleep(5000)
_WinAPI_EnableWindow ( $hGUI, True) ;odblokowanie dostępu do okna
GUICtrlSetData($hLab,"Kursor odblokowany")
Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE
_WinAPI_SetCapture
edytuj#include <WinAPI.au3> _WinAPI_SetCapture($hWnd)
Funkcja przechwytuje kursor myszki w danym oknie (kursor jest nieaktywny, ikona klepsydry). Zwraca uchwyt do okna, w którym poprzednio był przechwycony kursor, lub 0 gdy wystąpił błąd.
$hWnd - uchwyt do okna, w którym zostanie przechwycony kursor
_WinAPI_ReleaseCapture
edytuj#include <WinAPI.au3> _WinAPI_ReleaseCapture()
Funkcja zwalnia przechwytywanie kursora myszki. Zwraca True gdy sukces, lub False gdy wystąpił błąd.
Przykład:
#include <GUIConstantsEx.au3>
#include <WinAPI.au3>
$hGUI = GUICreate("_WinAPI_SetCapture", 400, 300)
$hLab = GUICtrlCreateLabel("KURSOR ZABLOKOWANY - Naciśnij ESC", 70, 80,220,70)
GUISetState()
Do
_WinAPI_SetCapture($hGUI) ;przechwycenie kursora
Until GUIGetMsg() = $GUI_EVENT_CLOSE
_WinAPI_ReleaseCapture() ;zwolnienie kursora
GUICtrlSetData($hLab,"KURSOR ODBLOKOWANY")
Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE
Pliki i programy
edytuj_WinAPI_CreateFile
edytuj#include <WinAPI.au3> _WinAPI_CreateFile($sFileName, $iCreation [, $iAccess = 4 [, $iShare = 0 [, $iAttributes = 0 [, $pSecurity = 0]]]])
Funkcja tworzy lub otwiera plik o podanej nazwie. Zwraca otwarty uchwyt pliku, lub 0 gdy wystąpił błąd.
$sFileName - nazwa pliku do utworzenia lub otwarcia
$iCreation - działania odnoszące się do plików, które istnieją lub nie istnieją:
0 - tworzy nowy plik, funkcja nie działa, jeśli plik istnieje 1 - tworzy nowy plik, jeśli plik istnieje, to zostanie nadpisany 2 - otwiera plik, funkcja nie działa, jeśli plik nie istnieje 3 - otwiera plik, jeśli plik nie istnieje, funkcja tworzy plik 4 - otwiera plik i czyści go do rozmiaru 0 bajtów, funkcja nie działa, jeśli plik nie istnieje
$iAccess - dostęp do obiektu:
1 - wykonanie 2 - odczytanie 4 - zapisanie
$iShare - trybu udostępniania obiektu:
1 - usuwanie 2 - czytanie 4 - zapisanie
$iAttributes - atrybuty pliku:
1 - plik archiwalny 2 - Plik ukryty 4 - plik tylko do odczytu 8 - jest częścią lub jest wykorzystywany wyłącznie przez system operacyjny
$pSecurity - wskaźnik do struktury $tagSECURITY_ATTRIBUTES, która ustala, czy zwrócony uchwyt może być dziedziczony przez procesy potomne, jeśli $pSecurity = 0, uchwyt nie może być dziedziczony.
_WinAPI_ReadFile
edytuj#include <WinAPI.au3> _WinAPI_ReadFile($hFile, $pBuffer, $iToRead, ByRef $iRead [, $pOverlapped = 0])
Funkcja odczytuje dane z pliku. Zwraca True gdy sukces, lub False gdy wystąpił błąd.
$sFileName - nazwa pliku do utworzenia lub otwarcia
$pBuffer - wskaźnik do bufora do którego będą wczytywane dane
$iToRead - maksymalna liczba bajtów do odczytu
$iRead - liczba odczytanych bajtów
$pOverlapped - wskaźnik do $ tagOVERLAPPED
_WinAPI_WriteFile
edytuj#include <WinAPI.au3> _WinAPI_WriteFile($hFile, $pBuffer, $iToWrite, ByRef $iWritten [, $pOverlapped = 0])
Funkcja zapisuje w pliku, w położeniu określonym przez wskaźnik. Zwraca True gdy sukces, lub False gdy wystąpił błąd.
$hFile - uchwyt do pliku
$pBuffer - wskaźnik do bufora zawierającego dane do zapisu
$iToWrite - liczba bajtów do zapisu
$iWritten - liczba zapisanych bajtów
$pOverlapped - wskaźnik do $ tagOVERLAPPED
_WinAPI_SetFilePointer
edytuj#include <WinAPI.au3> _WinAPI_SetFilePointer($hFile, $iPos [, $iMethod = 0])
Funkcja przesuwa wskaźnik pliku o podaną ilość pozycji. Zwraca nowe położenie wskaźnika. Jeżeli wystąpił błąd makro @error <> 0.
Wskaźnik pliku to pozycja, od której rozpoczyna się zapis lub odczyt danych w pliku.
$hFile - uchwyt do pliku
$iPos - ilość bajtów, o które zostanie przesunięty wskaźnik pliku, wartość dodatnia oznacza przesunięcie w kierunku końca pliku, ujemna w kierunku początku (maksymalna wartość 2^32)
$iMethod - początkowa pozycja wskaźnika, może to być jedna z następujących wartości:
0 - początek pliku (domyślnie) 1 - aktualne położenie wskaźnika 2 - koniec pliku
UWAGA: Funkcja może być użyta do odczytu aktualnego położenia wskaźnika. W takim przypadku należy podać $iPos = 0 i $iMethod = 1.
_WinAPI_SetEndOfFile
edytuj#include <WinAPI.au3> _WinAPI_SetEndOfFile($hFile)
Funkcja ustawia fizyczny rozmiar podanego pliku w bieżącej pozycji wskaźnika pliku. Zwraca True gdy sukces, lub False gdy wystąpił błąd (makro @extended zawiera kod błędu, taki jak zwracany przez _WinAPI_GetLastError).
$hFile - uchwyt do pliku
UWAGA: Funkcja ta może być użyta do zmniejszenia lub zwiększenia plik, a więc do ustawienia jego rozmiaru. Jeśli plik jest zwiększany zawartość pomiędzy starym i nowym końcem pliku nie jest zdefiniowana.
Przykład:
#include <WinAPI.au3>
Local $nBytes, $sFile = 'test.txt'
$sTxt1 = 'abcdefghijklmnopqrstuvwxyz' & @LF & '1234567890'
$len1 = StringLen($sTxt1)
$tBuffer = DllStructCreate("char[" & $len1 & "]")
DllStructSetData($tBuffer, 1, $sTxt1) ;tworzenie struktury z danymi
;tworzenie pliku tekstowego
$hFile = _WinAPI_CreateFile($sFile, 1) ;utworzenie pliku
_WinAPI_WriteFile($hFile, DllStructGetPtr($tBuffer), $len1, $nBytes)
_WinAPI_CloseHandle($hFile) ;zamknięcie pliku
MsgBox(0,"Test 1", FileRead($sFile))
;odczyt 6 znaków z pliku, poczynając od poz. 3
$tBuffer = DllStructCreate("char[6]")
$hFile = _WinAPI_CreateFile($sFile, 2, 2) ;otwarcie pliku do odczytu
_WinAPI_SetFilePointer($hFile, 3) ;wskaźnik na poz. 3
_WinAPI_ReadFile($hFile, DllStructGetPtr($tBuffer), 6, $nBytes) ;odczyt 6 bajtów
_WinAPI_CloseHandle($hFile)
MsgBox(0,"Test 2", DllStructGetData($tBuffer, 1))
;wstawienie do pliku nowych danych 6 znaków od poz. 30
$sTxt2 = "#####"
$len2 = StringLen($sTxt2)
$tBuffer = DllStructCreate("char[" & $len2 & "]")
DllStructSetData($tBuffer, 1, $sTxt2)
$hFile = _WinAPI_CreateFile($sFile, 2, 4)
_WinAPI_SetFilePointer($hFile, 28)
_WinAPI_WriteFile($hFile, DllStructGetPtr($tBuffer), $len2, $nBytes)
_WinAPI_CloseHandle($hFile)
MsgBox(0,"Test 3", FileRead($sFile))
;skrócenie pliku na poz. 29
$hFile = _WinAPI_CreateFile($sFile, 2, 4)
_WinAPI_SetFilePointer($hFile, 29) ;wskaźnik na poz. 29
_WinAPI_SetEndOfFile($hFile) ;ustawienie końca pliku
_WinAPI_CloseHandle($hFile)
MsgBox(0,"Test 4", FileRead($sFile))
_WinAPI_GetFileSizeEx
edytuj#include <WinAPI.au3> _WinAPI_GetFileSizeEx($hFile)
Funkcja zwraca wielkość pliku. Jeżeli wystąpi błąd ustawiane jest makro @error.
$hFile - uchwyt do pliku
_WinAPI_GetOpenFileName
edytuj #include <WinAPI.au3>
_WinAPI_GetOpenFileName ( [$sTitle = "" [, $sFilter = "All files ( *.* ) " [, $sInitalDir = "." [, $sDefaultFile = ""
[, $sDefaultExt = "" [, $iFilterIndex = 1 [, $iFlags = 0 [, $iFlagsEx = 0 [, $hwndOwner = 0]]]]]]]]] )
Funkcja wywołuje systemowy selektor do otwarcia plików. Zwraca jednowymiarową tablicę z danymi wybranych plików. Jeżeli wystąpi błąd (np. nie wybrano żadnego pliku), zwracana jest jednoelementowa tablica zawierająca wartość 0.
Zawartość zwracanej tablicy:
$Tablica[0] - liczba łańcuchów tekstowych, jest równa ilości wybranych plików + 1 = n $Tablica[1] - ścieżka dostępu do wybranego pliku (plików) $Tablica[2] - nazwa wybranego pliku ... $Tablica[n] - nazwa wybranego pliku
$sTitle - nazwa okna selektora
$sFilter - zestaw filtrów określający jakie pliki będą wyświetlane. Każdy składa się z dwóch elementów. Pierwszym elementem to jego opis, który będzie wyświetlany w oknie selektora, np.: "Pliki tekstowe". Drugi element filtru opisuje maskę pliku, np.: "*.txt".
Aby opisać zestaw masek w jednym filtrze, należy rozdzielić je znakiem średnika (;), np.: "(*.TXT;*.DOC;*.BAK)".
Maska może być kombinacją zwykłych znaków i symboli wieloznacznych (* - dowolna ilość dowolnych znaków, ? - jeden dowolny znak), np.: "a*.???" oznacza dowolną nazwę zaczynająca się na a, i dowolne 3-literowe rozszerzenie nazwy. Nie należy używać spacji w masce.
Filtry można łączyć w zestawy rozdzielając poszczególne składniki znakiem pionowej kreski (|).
Pełny zestaw filtrów może wyglądać np. tak: "Pliki Graficzne (*.bmp;*.jpg;*.gif) | Pliki tekstowe (*.txt) | Pliki audio (*.MP3;*.Wav;*.WMA)"
$sInitalDir - początkowy folder, kropka (".") oznacza folder bieżący uruchomionego skryptu (wartość domyślna).
$sDefaultFile - wyjściowa nazwa pliku, która będzie wyświetlona w polu "Nazwa pliku:", domyślnie jest string pusty czyli brak nazwy.
$sDefaultExt - wyjściowe rozszerzenie nazwy pliku, domyślnie jest string pusty czyli brak wyjściowego rozszerzenia.
$iFilterIndex - numer filtru, który będzie aktywny po wywołaniu selektora
$iFlags - flaga, pełny opis w dokumentacji AutoIt'a, jak dla struktury $tagOPENFILENAME, np.: $OFN_ALLOWMULTISELECT = 0x80000 - możliwość wybrania większej ilości plików, $OFN_EXPLORER = 0x200 - selektor w nowym stylu.
$iFlagsEx - flaga rozszerzona, pełny opis w dokumentacji AutoIt'a, jak dla struktury $tagOPENFILENAME.
$hwndOwner - uchwyt do okna nadrzędnego
Przykład:
#include <WinAPI.au3>
$aFile = _WinAPI_GetOpenFileName( "Test selektora plików", _
"Pliki grafiki(*.jpg;*.bmp;*.gif) | Skrypt(*.au3)", _
"", "", "", 1, BitOR($OFN_ALLOWMULTISELECT, $OFN_EXPLORER))
$iFile = (UBound($aFile)>1 ? $aFile[0]-1 : 0)
$txt = "Ilość wybranych plików: " & $iFile
If $iFile Then
$txt &= @LF & "Ścieżka do plików: " & $aFile[1]
For $i = 1 To $iFile
$txt &= @LF & "Nazwa pliku " & $i & ": "& $aFile[$i + 1]
Next
EndIf
MsgBox(0, "Wybrane pliki", $txt)
_WinAPI_GetSaveFileName
edytuj #include <WinAPI.au3>
_WinAPI_GetSaveFileName ( [$sTitle = "" [, $sFilter = "All files ( *.* ) " [, $sInitalDir = "." [, $sDefaultFile = ""
[, $sDefaultExt = "" [, $iFilterIndex = 1 [, $iFlags = 0 [, $iFlagsEx = 0 [, $hwndOwner = 0]]]]]]]]] )
Funkcja wywołuje systemowy selektor do zapisywania pliku. Zwraca jednowymiarową tablicę z danymi wybranego pliku. Jeżeli wystąpi błąd (np. nie wybrano żadnego pliku), zwracana jest jednoelementowa tablica zawierająca wartość 0.
Zawartość zwracanej tablicy:
$Tablica[0] - liczba łańcuchów tekstowych, 2 jeśli wybrano plik $Tablica[1] - ścieżka dostępu do wybranego pliku $Tablica[2] - nazwa wybranego pliku
Wszystkie parametry jak dla _WinAPI_GetOpenFileName.
_WinAPI_FlushFileBuffers
edytuj#include <WinAPI.au3> _WinAPI_FlushFileBuffers($hFile)
Funkcja powoduje zapisanie buforowanych danych do pliku. Zwraca True gdy sukces, lub False gdy wystąpił błąd.
$hFile - uchwyt do pliku
_WinAPI_FindExecutable
edytuj#include <WinAPI.au3> _WinAPI_FindExecutable($sFileName [, $sDirectory = ""])
Funkcja zwraca ścieżkę do programu (pliku wykonywalnego) skojarzonego z określonym plikiem, lub pusty string gdy wystąpił błąd (w @error ustawiony jest kod błędu).
$sFileName - pełna ścieżka do istniejącego pliku
$sDirectory - ścieżka do domyślnego katalogu
Przykład:
#include <WinAPI.au3>
$sPath = FileOpenDialog("Wybierz plik", @mydocumentsdir, "Wszystkie (*.*)", 1 + 2)
If Not @error Then
MsgBox(0, "Aplikacja skojarzone z plikiem", "Plik: " & @LF & $sPath & @LF & @LF & _
"Skojarzona aplikacja: " & @lf & _WinAPI_FindExecutable($sPath))
EndIf
_WinAPI_GetModuleHandle
edytuj#include <WinAPI.au3> _WinAPI_GetModuleHandle ( $sModuleName )
Funkcja zwraca uchwyt dla określonego modułu. Moduł musi być ładowany przez proces wywołujący. Gdy wystąpił błąd zwracane jest 0.
$sModuleName - nazwa załadowanego modułu (*.dll lub *.exe). Jeżeli pominiemy rozszerzenie to domyślnie zostanie przyjęte jako .dll. Jeżeli moduł nie posiada rozszerzenia, to nazwę należy zakończyć kropką (np. moj_modul.). Wartość NULL zamiast nazwy oznacza, że zostanie zwrócony uchwyt do własnego procesu (skryptu).
Powiadomienia i komunikaty
edytuj_WinAPI_MessageBeep
edytuj#include <WinAPI.au3> _WinAPI_MessageBeep([$iType = 1])
Funkcja odtwarza określony dźwięk systemowy. Zwraca True gdy sukces, lub False gdy wystąpił błąd.
$iType - kod dźwięku
0 - normalny sygnał 1 - OK 2 - błąd 3 - pytanie 4 - wykrzyknik 5 - gwiazdka
Przykład:
#include <WinAPI.au3>
MsgBox(0,"Test dźwiękowy", "0 - Normalny dźwięk")
_WinAPI_MessageBeep(0)
MsgBox(0,"Test dźwiękowy", "1 - OK")
_WinAPI_MessageBeep(1)
MsgBox(0,"Test dźwiękowy", "2 - błąd")
_WinAPI_MessageBeep(2)
MsgBox(0,"Test dźwiękowy", "3 - pytanie")
_WinAPI_MessageBeep(3)
MsgBox(0,"Test dźwiękowy", "4 - wykrzyknik")
_WinAPI_MessageBeep(4)
MsgBox(0,"Test dźwiękowy", "5 - gwiazdka")
_WinAPI_MessageBeep(5)
_WinAPI_FatalAppExit
edytuj#include <WinAPI.au3> _WinAPI_FatalAppExit ( $sMessage )
Funkcja wyświetla okno komunikatu i kończy działanie skryptu. Nie zwraca żadnej wartości.
UWAGA: Używać _WinAPI_FatalAppExit tylko wtedy, gdy nie ma możliwości zakończenia skryptu w inny sposób. Funkcja może nie zwolnić całej pamięci używanej przez skrypt oraz nie zamknąć wszystkich używanych przez niego plików.
Może to spowodować ogólną awarię systemu.
Przykład:
#include <WinAPI.au3>
_WinAPI_FatalAppExit ("To już konic!")
MsgBox(0, "???", "To i tak się nie wyświetli!")
_WinAPI_ShowError
edytuj#include <WinAPI.au3> _WinAPI_ShowError($sText [, $fExit = True])
Funkcja wyświetla okienko powiadomienia o błędzie i generuje stosowny sygnał dźwiękowy. Nie zwraca żadnej wartości.
$sText - treść powiadomienia
$fExit - określa czy działanie skryptu ma być przerwane po zamknięciu okienka, True - tak, False - nie
Przykład:
#include <WinAPI.au3>
_WinAPI_ShowError('Wystąpił przerażający błąd!', False)
MsgBox(4096, 'Bardzo ważna informacja!', 'Mimo wszystko próbujmy działąć dalej.')
_WinAPI_ShowError('Błąd jeszcze straszniejszy!')
MsgBox(4096, 'Nie ma co pisać, i tak się nie wyświetli', '')
_WinAPI_ShowMsg
edytuj#include <WinAPI.au3> _WinAPI_ShowMsg($sText)
Funkcja wyświetla okienko informacyjne i generuje stosowny sygnał dźwiękowy. Nie zwraca żadnej wartości.
$sText - treść powiadomienia
Przykład:
#include <WinAPI.au3>
_WinAPI_ShowMsg('To jest bardzo ważna informacja!')
_WinAPI_MsgBox
edytuj#include <WinAPI.au3> _WinAPI_MsgBox($iFlags, $sTitle, $sText)
Funkcja wyświetla okienko komunikatu. Nie zwraca żadnej wartości.
$iFlags - flaga (jak dla MsgBox)
$sTitle - tekst na belce
$sText - tekst wewnątrz okienka
UWAGA: Funkcja jest bardzo podobna do MsgBox. Różnicą jest to, że nie można ustalić czasu, po którym okno automatycznie się zamknie.
Ponieważ funkcja nie zwraca żadnej wartości, używanie flagi o większej ilości przycisków jest pozbawione sensu (nie można rozpoznać, który przycisk został użyty).
W odróżnieniu od MsgBox, _WinAPI_MsgBox powoduje automatyczne odblokowanie klawiatury i myszy, co ilustruje poniższy przykład:
#include <WinAPI.au3>
BlockInput(1)
_WinAPI_MsgBox(64, '_WinAPI_MsgBox', 'Automatyczne odblokowanie')
BlockInput(1)
MsgBox(64, 'MsgBox', 'Odblokowanie po 3 sek.',3)
BlockInput(0)
_WinAPI_GetLastError
edytuj#include <WinAPI.au3> _WinAPI_GetLastError ( )
Funkcja zwraca kod ostatniego błędu powstałego w aktualnym wątku.
_WinAPI_GetLastErrorMessage
edytuj#include <WinAPI.au3> _WinAPI_GetLastErrorMessage ( )
Funkcja zwraca komunikat ostatniego błędu powstałego w aktualnym wątku.
_WinAPI_SetLastError
edytuj#include <WinAPI.au3> _WinAPI_SetLastError ( $iErrorCode )
Funkcja ustawia kod ostatniego błędu powstałego w aktualnym wątku.
$iErrorCode - kod błędu
Przykład:
#include <WinAPI.au3>
FileOpen ("ble ble ble") ;próba otwarcia nieistniejącego pliku celem wywołania błędu systemowego
MsgBox(64, "Błąd:", _WinAPI_GetLastError() &" - " & _WinAPI_GetLastErrorMessage())
_WinAPI_SetLastError(66) ;"ręczne" ustawienie kodu błędu
MsgBox(64, "Błąd:", _WinAPI_GetLastError() &" - " & _WinAPI_GetLastErrorMessage())
_WinAPI_PostMessage
edytuj#include <WinAPI.au3> _WinAPI_PostMessage ( $hWnd, $iMsg, $wParam, $lParam )
Funkcja wysyła komunikat do okna )kontrolki). Zwraca True gdy sukces, lub False gdy wystąpił błąd (informacje o błedzie można odczytać funkcją _WinAPI_GetLastError.
$hWnd - Uchwyt okna (kontrolki) która otrzyma komunikat. Jeśli parametr wynosi 0xFFFF (HWND_BROADCAST),to komunikat zostanie wysłany do wszystkich okien najwyższego poziomu w systemie, włączając w to okna nieaktywne, niewidoczne, pokrywające się i pop-up Komunikat nie jest natomiast wysyłana do okien podrzędnych.
$iMsg - wysyłany komunikat
$wParam - pierwszy parametr komunikatu (zależny od rodzaju komunikatu)
$lParam - drugi parametr komunikatu (zależny od rodzaju komunikatu)
Komunikat | Opis | $wParam | $lParam --------------------------------------------------------------------------------------------------------------------- $WM_LBUTTONDBLCLK | Dwukrotne wciśnięcie LPM (dwuklik) | Współrzędne x i y | "" $WM_LBUTTONDOWN | Wciśnięcie i przytrzymanie LPM | Współrzędne x i y | "" $WM_LBUTTONUP | Puszczenie LPM | Współrzędne x i y | "" --------------------------------------------------------------------------------------------------------------------- $WM_MBUTTONDBLCLK | J/w dla środkowego przycisku myszy | Współrzędne x i y | "" $WM_MBUTTONDOWN | | Współrzędne x i y | "" $WM_MBUTTONUP | | Współrzędne x i y | "" --------------------------------------------------------------------------------------------------------------------- $WM_RBUTTONDBLCLK | J/w dla prawego przycisku myszy | | $WM_RBUTTONDOWN | | Współrzędne x i y | "" $WM_RBUTTONUP | | Współrzędne x i y | "" ---------------------------------------------------------------------------------------------------------------------
Przykład:
#include <WindowsConstants.au3>
#include <WinAPI.au3>
Run("calc.exe")
Sleep(1000)
WinSetState("Kalkulator", "", @SW_HIDE)
Sleep(200)
Local $hHandle = ControlGetHandle("Kalkulator", "", "5")
Local $iCoordinates = _WinAPI_MakeLong(10,10)
For $i=1 To 5
_WinAPI_PostMessage($hHandle, $WM_LBUTTONDOWN, "", $iCoordinates )
_WinAPI_PostMessage($hHandle, $WM_LBUTTONUP, "", $iCoordinates )
Next
Sleep(1000)
WinSetState("Kalkulator", "", @SW_SHOW)
System
edytuj_WinAPI_CloseHandle
edytuj#include <WinAPI.au3> _WinAPI_CloseHandle($hObject)
Funkcja zamyka otwarty uchwyt obiektu. Zwraca True gdy sukces, lub False gdy wystąpił błąd.
$hObject - uchwyt obiektu, np. okna, pliku, itp.
_WinAPI_EnumDisplayDevices
edytuj#include <WinAPI.au3> _WinAPI_EnumDisplayDevices ( $sDevice, $iDevNum )
Funkcja zwraca informacje na temat urządzeń wyświetlających w systemie. Jeżeli wystąpił błąd makro @error przyjmuje wartość różną od zera.
$sDevice - nazwa urządzenia. Jeżeli pusta, funkcja zwraca informacje dla kart graficznych.
$iDevNum - numer (indeks) urządzenia
Informacje są zwracane w postaci jednowymiarowej tablicy:
[1] - True
[2] - adapter lub monitor
[3] - opis adaptera lub monitora
[4] - flaga statusu urządzenia (suma następujących wartości):
1 - urządzenie jest częścią pulpitu
2 - podstawowy pulpit jest na tym urządzeniu, dla systemów z jedną kartą graficzną jest zawsze ustawione,
dla systemów z wieloma kartami graficznymi, może być ustawione tylko dla jednej z nich.
4 - wirtualne urządzenie dla usług zdalnego dostępu
8 - urządzenie jest kompatybilne z VGA
16 - urządzenie wymienne, nie jest głównym wyświetlaczem
32 - urządzenie posiada więcej trybów wyświetlania niż wsparcie urządzeń wyjściowych
Przykład:
#include <WinAPI.au3>
Local $aDev, $i=0, $txt
While 1
$aDev = _WinAPI_EnumDisplayDevices("", $i)
If Not $aDev[0] Then ExitLoop
$txt = "Sukces? " & $aDev[0] & @CRLF
$txt &= "Urządzenie (Adapter lub monitor): " & $aDev[1] & @CRLF
$txt &= "Opis (Adapter lub monitor): " & $aDev[2] & @CRLF
$txt &= "Flaga statusu urządzenia: " & $aDev[3] & @CRLF
If BitAND($aDev[3], 32) Then $txt &= @TAB & "- Urządzenie ma więcej trybów wyświetlania niż wsparcie urządzeń wyjściowych" & @CRLF
If BitAND($aDev[3], 16) Then $txt &= @TAB & "- Urządzenie wymienne, nie jest głównym wyświetlaczem" & @CRLF
If BitAND($aDev[3], 8) Then $txt &= @TAB & "- Urządzenie kompatybilne z VGA" & @CRLF
If BitAND($aDev[3], 4) Then $txt &= @TAB & "- Wirtualne urządzenie dla usług zdalnego dostępu" & @CRLF
If BitAND($aDev[3], 2) Then $txt &= @TAB & "- Urządzenie podstawowego pulpitu" & @CRLF
If BitAND($aDev[3], 1) Then $txt &= @TAB & "- Urządzenie znajduje się w pulpicie" & @CRLF
$txt &= "Ciąg identyfikatora Plug and Play: " & $aDev[4] & @CRLF
MsgBox(0, "", $txt)
$i += 1
WEnd
_WinAPI_GlobalMemoryStatus
edytuj#include <WinAPI.au3> _WinAPI_GlobalMemoryStatus ( )
Funkcja zwraca informacje na temat aktualnie dostępnej pamięci operacyjnej. Jeżeli wystąpił błąd makro @error przyjmuje wartość różną od zera.
Informacje są zwracane w postaci jednowymiarowej tablicy:
[0] - procent zajętej pamięci [1] - całkowity rozmiar fizycznej pamięci [2] - rozmiar wolnej pamięci fizycznej [3] - całkowity rozmiar pliku stronicowania [4] - wolny obszar pliku stronicowania [5] - całkowity rozmiar pamięci użytkownika [6] - rozmiar wolnej pamięci użytkownika
Przykład:
#include <WinAPI.au3>
#include <WinAPI.au3>
$aMemInfo = _WinAPI_GlobalMemoryStatus()
$sMemInfo = "Procent zajętej pamięci: " & $aMemInfo[0] & "%" & @CRLF & @CRLF & _
"Całkowity rozmiar fizycznej pamięci:" & @TAB & $aMemInfo[1] & @CRLF & @CRLF & _
"Rozmiar wolnej pamięci fizyczne:" & @TAB & $aMemInfo[2] & @CRLF & @CRLF & _
"Całkowity rozmiar pliku stronicowania:" & @TAB & $aMemInfo[3] & @CRLF & @CRLF & _
"Wolny obszar pliku stronicowania:" & @TAB & $aMemInfo[4] & @CRLF & @CRLF & _
"Całkowity rozmiar pamięci użytkownika:" & @TAB & $aMemInfo[5] & @CRLF & @CRLF & _
"Rozmiar wolnej pamięci użytkownika:" & @TAB & $aMemInfo[6]
MsgBox(64, "Pamięć operacyjna:", $sMemInfo)
_WinAPI_ExpandEnvironmentStrings
edytuj#include <WinAPI.au3> _WinAPI_ExpandEnvironmentStrings ( $sString )
Funkcja zwraca string odpowiadający danej zmiennej środowiskowej. Jeżeli wystąpił błąd makro @error przyjmuje wartość różną od zera.
$sString - nazwa zmiennej systemowej
Przykład:
#include <WinAPI.au3>
MsgBox(0, "String zmiennej środowiskowej", "%windir% = " & _
_WinAPI_ExpandEnvironmentStrings("%windir%"))
_WinAPI_GetSystemMetrics
edytuj#include <WinAPI.au3> _WinAPI_GetSystemMetrics($iIndex)
Funkcja zwraca określoną metrykę lub ustawienie konfiguracji systemu. Jeżeli wystąpił błąd zwracane jest 0.
$iIndex - indeks parametru systemu, który chcemy poznać
0 - szerokość ekranu w pikselach
1 - wysokość ekranu w pikselach
2 - szerokość pionowego paska przewijania w pikselach
3 - wysokość poziomego paska przewijania w pikselach
4 - wysokość paska tytułowego okna w pikselach
5 - szerokość obramowanie okna w pikselach
7 - grubość ramy na obwodzie okna
8 - szerokość pionowej ramki wokół obwodu okna, które ma tytuł, ale nie zmienia swojego rozmiaru
9 - wysokość thumbbox'a na pionowym pasku przewijania
10 - szerokość thumbbox'a na poziomym pasku przewijania
11 - domyślna szerokość ikony w pikselach
12 - domyślna wysokość ikony w pikselach
13 - szerokość kursora w pikselach
14 - wysokość kursora w pikselach
15 - wysokość pojedynczej linii paska menu
16 - szerokość obszaru roboczego dla okna pełnoekranowego
17 - wysokość obszaru roboczego dla okna pełnoekranowego
20 - wysokość pionowego paska przewijania
21 - szerokość poziomego paska przewijania
23 - wartość niezerowa, jeśli znacznie lewego i prawego przycisku myszy zostało zamienione, inaczej 0
28 - minimalna szerokość okna w pikselach
29 - minimalna wysokość okna w pikselach
30 - szerokość przycisku w tytule okna lub na pasku tytułowym
36 - szerokość prostokąta wokół obszaru pierwszego kliknięcia w sekwencji podwójnego kliknięcia.
Drugie kliknięcie musi wystąpić w obszarze tego prostokąta, aby uznać dwa kliknięcia
za podwójne kliknięcie.
37 - jak 36 lecz dla wysokości prostokąta
43 - liczba przycisków myszy, 0 gdy mysz nie zainstalowana
67 - określa jak system został uruchomiony
0 - normalnie
1 - w trybie awaryjny
2 - w trybie awaryjnym z obsługą sieci
_WinAPI_SystemParametersInfo
edytuj#include <WinAPI.au3> _WinAPI_SystemParametersInfo($iAction [, $iParam = 0 [, $vParam = 0 [, $iWinIni = 0]]])
Funkcja obiera albo ustawia wartość jednego z parametrów systemu. Funkcja ta może również zaktualizować profil użytkownika podczas ustawiania parametru. Zwraca True gdy sukces lub False gdy wystąpił błąd.
_WinAPI_GetSysColor
edytuj#include <WinAPI.au3> _WinAPI_GetSysColor($iIndex)
Funkcja zwraca kod koloru elementów systemowych okien (w formacie BGR).
$iIndex - kod elementu, którego kolor ma być zwrócony przez funkcję
$COLOR_3DDKSHADOW | 21 | ciemny cień elementów trójwymiarowych $COLOR_3DFACE | 15 | kolor tła trójwymiarowych elementów dialogowych $COLOR_3DHILIGHT | 20 | kolor trójwymiarowego elementy ekranu (na krawędzi skierowanej do źródła światła) $COLOR_3DLIGHT | 22 | kolor trójwymiarowe elementy ekranu (na krawędzi skierowaną do źródła światła.) $COLOR_3DSHADOW | 16 | kolor cienia trójwymiarowe elementu ekranu (na krawędzi przeciwległych do źródła światła) $COLOR_ACTIVEBORDER | 10 | granice aktywnego okna $COLOR_ACTIVECAPTION | 2 | aktywny pasek tytułu $COLOR_APPWORKSPACE | 12 | obszar roboczy aplikacji (MDI). $COLOR_BTNTEXT | 18 | kolor tekstu na przycisku $COLOR_CAPTIONTEXT | 9 | kolor tekstu tytułu $COLOR_DESKTOP | 1 | kolor tła pulpitu $COLOR_GRADIENTACTIVECAPTION | 27 | kolor gradientu w prawej stronie tytułu aktywnego okna $COLOR_ACTIVECAPTION | 2 | kolor aktywnego paska tytułu $COLOR_GRADIENTINACTIVECAPTION | 28 |kolor gradientu w prawej stronie tytułu nieaktywnego okna $COLOR_INACTIVECAPTION | 3 | określa lewy kolor boczny $COLOR_GRAYTEXT | 17 | szary tekst (niedostępny) $COLOR_HIGHLIGHT | 13 | pozycja (pozycje) wybrana w kontrolce $COLOR_HIGHLIGHTTEXT | 14 | kolor tekstu elementu (elenentów) wybranego w kontrolce $COLOR_HOTLIGHT | 26 | kolor dla hiperłącza i pozycji "hot-tracked" $COLOR_INACTIVEBORDER | 11 | kolor ramki nieaktywnego okna $COLOR_INACTIVECAPTION | 3 | kolor tytuł nieaktywnego okna $COLOR_INACTIVECAPTIONTEXT | 19 | kolor tekstu w nagłówku nieaktywnego okna $COLOR_INFOBK | 24 | tło tooltip'u $COLOR_INFOTEXT | 23 | tekst na tooltip'ie $COLOR_MENU | 4 | kolor tła menu $COLOR_MENUHILIGHT | 29 | kolor pozycji menu, gdy menu jest płaskie $COLOR_MENUBAR | 30 | kolor tła menu, gdy menu jest płaskie $COLOR_MENUTEXT | 7 | kolor tekstu w menu $COLOR_SCROLLBAR | 0 | szary obszar paska przewijania $COLOR_WINDOW | 5 | kolor tła okna $COLOR_WINDOWFRAME | 6 | kolor ramy okna $COLOR_WINDOWTEXT | 8 | kolor tekstu w oknie
_WinAPI_SetSysColors
edytuj#include <WinAPI.au3> _WinAPI_SetSysColors($vElements, $vColors)
Funkcja ustawia kolor elementów okien. Zwraca True gdy sukces, lub False gdy wystąpił błąd.
$vElements - kod elementu, lub tablica kodów (kody jak dla _WinAPI_SetGetColors)
$vColors - kod koloru, lub tablica kodów (format BRG)
UWAGA: Zmiana kolorów będzie aktualna nawet po zakończeniu skryptu!
Przykład:
#include <WinAPI.au3>
GUICreate("Testowy GUI", 300, 200)
GUISetState()
$xcol = 15
$wincol = _WinAPI_GetSysColor($xcol) ;odczyt koloru
_WinAPI_SetSysColors($xcol, 0xff) ;ustawienie nowego koloru
MsgBox(0, "Test", "Pierwotny kolor: " & Hex($wincol) & @LF & _
"Nowy kolor : " & Hex(_WinAPI_GetSysColor($xcol)))
_WinAPI_SetSysColors($xcol, $wincol) ;odtworzenie pierwotnego koloru
_WinAPI_SetDefaultPrinter
edytuj#Include <WinAPI.au3> _WinAPI_SetDefaultPrinter ($Sprinter)
Funkcja ustawia domyślną drukarkę dla bieżącego użytkownika na komputerze lokalnym. Zwraca True gdy sukces, lub False gdy wystąpił błąd.
$Sprinter - domyślna nazwa drukarki. Do zdalnego wydruku nazwa ma postać: "\\server\NazwaDrukarki", dla drukarki lokalnej: "NazwaDrukarki". Jeśli tym parametrem jest "" (pusty string), to funkcja nie robi nic, o ile drukarka domyślna jest już zdefiniowana. Jednakże, jeśli domyślna drukarka nie jest dostępna, to funkcja sprawia, że pierwsza na liście drukarek będzie ustawiona jako domyślna (o ile jest jakaś drukarka na liście).
Haki
edytujHak (ang. hook) - mechanizm pozwalający na przechwytywanie określonych wiadomości systemowych zanim dotrą do docelowej aplikacji.
Wyróżniamy dwa typy haków:
- lokalne (thread hooks) – pozwalają przechwytywać wiadomości skierowane do określonego wątku,
- globalne (system-wide hooks) – pozwalają przechwytywać wszystkie wiadomości danego typu wysyłane przez system.
Haki można podpiąć do wielu wiadomości systemowych. Podczas wystąpienia którejś z nich (np. wciśnięcie klawisza, tworzenie okna...) Windows sprawdza czy istnieją zarejestrowane dla niej haki.
Jeżeli tak – normalne operacje związane z wykonaniem zadania zostają zawieszone i kontrolę nad zdarzeniem przejmuje funkcja haka.
Do niej należy przekazanie sterowania do kolejnych haków oraz poprawne przetworzenia wiadomości.
W przypadku zarejestrowania więcej niż jednego haka dla danego zdarzenia zostaje budowany tzw. łańcuch haków („hook chain”).
Jest to struktura typu LIFO - funkcja zarejestrowana najpóźniej otrzymuje możliwość działania jako pierwsza.
Co z tego wynika? Hak zainstalowany jako ostatni może skutecznie ograniczyć wcześniejszym dostęp do informacji. System operacyjny odzyskuje kontrolę po zakończeniu działania wszystkich haków.
Haki mają wiele zastosowań. Programy antywirusowe mogą instalować swoje haki aby przechwytywać otrzymywane/wysyłane e-maile i sprawdzać ich bezpieczeństwo.
Keyloggery gromadzą wciśnięcia wszystkich klawiszy. Nic nie stoi na przeszkodzie, aby nasz system wzbogadcić o obsługę gestów myszki.
Dodanie specyficznych skrótów klawiszowych także nie będzie problemem. Haki umożliwiają też badanie aktywności użytkownika poprzez nasłuchiwanie aktywności klawiatury i myszki.
Oprócz tego mogą być przydatne przy debugowaniu aplikacji – dają bezpośredni dostęp do komunikatów systemu dla danego programu.
Procedury dla haków globalnych muszą obowiązkowo znajdować się w bibliotece DLL.
_WinAPI_SetWindowsHookEx
edytuj#include <WinAPI.au3> _WinAPI_SetWindowsHookEx ( $iHook, $pProc, $hDll [, $iThreadId = 0] )
Funkcja zakłada hak na początku łańcucha i zwraca uchwyt do niego. Jeżeli wystąpił błąd zwracane jest 0, a informację o błędzie można odczytać za pomocą funkcji _WinAPI_GetLastError().
_SetWindowsHookEx powinniśmy wywołać tam, gdzie wykonujemy inicjalizację naszej aplikacji - np. po stworzeniu głównego okna.
$iHook - Określa typ procedury haka do zainstalowania:
$WH_CALLWNDPROC oraz $WH_CALLWNDPROCRET - pozwalają monitorować komunikaty przeznaczone dla konkretnej procedury okna. $WH_CALLWNDPROC przechwytuje komunikat przed jego dotarciem do procedury okna, $WH_CALLWNDPROCRET - po. $WH_CBT - nazwa pochodzi od computer-based training (CBT), czyli komputerowej edukacji, dla którego to rodzaju aplikacji przede wszystkim powstał ten hak. Pozwala przechwytywać komunikaty przed utworzeniem, zniszczeniem, minimalizacją, maksymalizacją, przeniesieniem, zmianą rozmiaru okna, przed wykonaniem polecenia systemowego, przed zdjęciem komunikatu myszy lub klawiatury z kolejki komunikatów, przed ustawieniem fokusa oraz przed synchronizacją kolejki komunikatów. Dzięki temu możemy określić, czy nasza aplikacja "pozwala" na te operacje czy też nie. Teraz już co niektórzy mogą kojarzyć - tak, wszelkiego rodzaju komputerowe testy, quizy i programy egzaminacyjne korzystają z tego, by zablokować biednym studentom dostęp do pomocy naukowych. $WH_DEBUG - ten hak wywoływany jest zawsze przed wszystkimi innymi hakami, więc można go użyć do "odpluskwiania" innych haków. $WH_FOREGROUNDIDLE - hak pozwalający nam wykonywać różne zadania w tle, gdy system wykryje, że pierwszoplanowy wątek nic w danej chwili nie robi. $WH_GETMESSAGE - pozwala przechwycić komunikat, który właśnie ma być zwrócony przez GetMessage lub PeekMessage (w przeciwieństwie do $WH_CALLWNDPROC, który przechwytuje komunikat już po wywołaniu DispatchMessage). To jest właśnie najbardziej zalecany hak do przechwytywania komunikatów związanych z myszą i klawiaturą. $WH_JOURNALPLAYBACK - ciekawy hak, który umożliwia odtworzenie "nagranych" wcześniej zdarzeń wejściowych (np. ruchu myszy). Jest to hak globalny, dotyczący wszystkich wątków w systemie. $WH_JOURNALRECORD - "nagrywa" zdarzenia do późniejszego wykorzystania przez $WH_JOURNALPLAYBACK, oczywiście to również jest hak globalny. $WH_KEYBOARD_LL - przechwytuje niskopoziomowe (low-level) zdarzenia, wywołane przez klawiaturę. $WH_KEYBOARD - przechwytuje wysokopoziomowe zdarzenia klawiatury (jest to więc wyspecjalizowany wariant haka $WH_GETMESSAGE). $WH_MOUSE_LL - przechwytuje niskopoziomowe zdarzenia myszy. $WH_MOUSE - przechwytuje wysokopoziomowe zdarzenia myszy (kolejna wyspecjalizowana wersja $WH_GETMESSAGE). $WH_MSGFILTER oraz $WH_SYSMSGFILTER - dzięki tym hakom możemy monitorować komunikaty pochodzące z menu, pasków przewijania, message box'ów oraz okien dialogowych. Możemy też wykrywać aktywację okna przy pomocy Alt+Tab lub Alt+Esc. Normalnie nie możemy tego wszystkiego zrobić, gdy wykonywana jest jakakolwiek pętla modalna np. wewnętrzna pętla message box'a). $WH_SYSMSGFILTER ma działanie globalne, zaś $WH_MSGFILTER dotyczy jedynie aplikacji, która zainstalowała hak. $WH_SHELL - został stworzony po to, byśmy w aplikacji shell'owej mogli otrzymywać istotne powiadomienia systemowe. Domyślnie jest to aktywacja aplikacji shell'owej oraz utworzenie/zniszczenie jej głównego okna.
$pProc - wskaznik do procedury haka. Jeśli parametr $iThreadId wynosi zero lub określa identyfikator wątku utworzone przez inny proces, parametr $pProc musi wskazywać procedury haka w DLL.
$hDll - uchwyt do biblioteki DLL zawierającej procedurę haka wskazywana przez parametr $pProc. Dla lokalnych haków należy podać wartość NULL.
$iThreadId - określa identyfikator wątku, z którym procedura haka ma być związana. Jeśli parametr ten ma wartość zero, procedura haka jest związany z wszystkimi istniejącymi wątkami działającymi na tym samym pulpicie co wątek wywołujący.
UWAGA: Ponieważ funkcje haków globalnych muszą znajdować się w bibliotece DLL, za pomocą sanego AutoIt'a nie można założyć haków tego rodzaju (AutoIt nie umożliwia tworzenia plików DLL). Można natomiast zakładać haki globalne z wykorzystaniem plików DLL utworzonych za pomocą innych języków programowania.
_WinAPI_UnhookWindowsHookEx
edytuj#include <WinAPI.au3> _WinAPI_UnhookWindowsHookEx ( $hHook )
Funkcja usuwa haka zainstalowanego w łańcuchu haków za pomocą funkcji WinAPI_SetWindowsHookEx. Zwraca TRUE gdy sukces, lub FALSE gdy wystąpił błąd.
$hHook - uchwyt do usuwanego haka
_WinAPI_CallNextHookEx
edytuj#include <WinAPI.au3> _WinAPI_CallNextHookEx ( $hHook, $iCode, $wParam, $lParam )
Funkcja przekazuje sterowanie do procedury następnego haka w łańcuchu haków.
$hHook - ten parametr jest ignorowany
$iCode -
$wParam -
$lParam -
Przykład założenia łańcucha haków na klawiaturę:
#include <StructureConstants.au3>
#include <WinAPI.au3>
#include <WindowsConstants.au3>
OnAutoItExitRegister("Cleanup") ;rejestracja funkcji wywoływanej przy zakończeniu skryptu
Global $hHook1, $hKeyProc1, $hHook2, $hKeyProc2, $sLog
$hKeyProc1 = DllCallbackRegister("_KeyProc1", "long", "int;wparam;lparam") ;rejestracja funkcji callback pierwszego haka
$hHook1 = _WinAPI_SetWindowsHookEx($WH_KEYBOARD_LL, DllCallbackGetPtr($hKeyProc1), Null) ;założenie pierwszego haka
$hKeyProc2 = DllCallbackRegister("_KeyProc2", "long", "int;wparam;lparam") ;rejestracja funkcji callback drugiego haka
$hHook2 = _WinAPI_SetWindowsHookEx($WH_KEYBOARD_LL, DllCallbackGetPtr($hKeyProc2), Null) ;założenie drugiego haka
;pętla główna skryptu
While 1
Sleep(10)
WEnd
#Region Definicje funkcji
;funkcja callback dla pierwszego haka
Func _KeyProc1($nCode, $wParam, $lParam)
Local $tKEYHOOKS
$tKEYHOOKS = DllStructCreate($tagKBDLLHOOKSTRUCT, $lParam)
If $nCode < 0 Then
Return _WinAPI_CallNextHookEx($hHook1, $nCode, $wParam, $lParam) ;wywołanie kolejnego haka
EndIf
If $wParam = $WM_KEYDOWN Then
Modified_action_key1($tKEYHOOKS.vkCode)
EndIf
Return _WinAPI_CallNextHookEx($hHook1, $nCode, $wParam, $lParam) ;wywołanie kolejnego haka
EndFunc
;funkcja callback dla drugiego haka
Func _KeyProc2($nCode, $wParam, $lParam)
Local $tKEYHOOKS1
$tKEYHOOKS = DllStructCreate($tagKBDLLHOOKSTRUCT, $lParam)
If $nCode < 0 Then
Return _WinAPI_CallNextHookEx($hHook2, $nCode, $wParam, $lParam) ;;wywołanie kolejnego haka
EndIf
If $wParam = $WM_KEYDOWN Then
Modified_action_key2($tKEYHOOKS.vkCode)
EndIf
Return _WinAPI_CallNextHookEx($hHook2, $nCode, $wParam, $lParam) ;wywołanie kolejnego haka
EndFunc
;funkcja obsługi klawiatury przez pierwszego haka
Func Modified_action_key1($iKeyCode)
If $iKeyCode = 27 Then Exit ;zakończenie skryptu
If $iKeyCode = 49 Then Beep(262, 200) ;klawisze 1 do 8 grają gamę
If $iKeyCode = 50 Then Beep(294, 200)
If $iKeyCode = 51 Then Beep(330, 200)
If $iKeyCode = 52 Then Beep(349, 200)
If $iKeyCode = 53 Then Beep(392, 200)
If $iKeyCode = 54 Then Beep(440, 200)
If $iKeyCode = 55 Then Beep(494, 200)
If $iKeyCode = 56 Then Beep(523, 200)
If $iKeyCode = 65 Then ToolTip ("AutoIt to jest to!", 500, 200) ;klawisz A
$sLog &= Chr($iKeyCode) ;log klawiatury
EndFunc
;funkcja obsługi klawiatury przez drugiego haka
Func Modified_action_key2($iKeyCode)
If $iKeyCode = 66 Then ToolTip ("AutoIt to jest lipa!", 500, 250) ;klawisz B
EndFunc
;funkcja kończąca skrypt po wciśnięciu ESC
;zwalnia zasoby i wyświetla historię użycia klawiatury (prymitywny keylogger)
Func Cleanup()
_WinAPI_UnhookWindowsHookEx($hHook1) ;usunięcie pierwszego haka
_WinAPI_UnhookWindowsHookEx($hHook2) ;usunięcie drugiego haka
DllCallbackFree($hKeyProc1) ;wyrejestrowanie funkcji callback pierwszego haka
DllCallbackFree($hKeyProc2) ;wyrejestrowanie funkcji callback drugiego haka
MsgBox(64, 'Log klawiatury:', $sLog) ;wyświetlenie loga
EndFunc
#EndRegion Koniec definicji funkcji
Arytmetyka bitowa
edytuj_WinAPI_HiWord
edytuj#include <WinAPI.au3> _WinAPI_HiWord($iLong)
Funkcja zwraca starsze słowo (2-bajtowe) z podwójnego słowa (4-bajtowego).
$iLong - podwójnego słowa (4-bajtowe)
_WinAPI_LoWord
edytuj#include <WinAPI.au3> _WinAPI_LoWord($iLong)
Funkcja zwraca młodsze słowo (2-bajtowe) z podwójnego słowa (4-bajtowego).
$iLong - podwójnego słowa (4-bajtowe)
Przykład:
#include <WinAPI.au3>
$iWord = 0xAAFFFF
MsgBox(0, $iWord, "Starsze słowo: " & Hex(_WinAPI_HiWord($iWord)) & @CRLF & _
"Młodsze słowo: " & Hex(_WinAPI_LoWord($iWord)))
_WinAPI_FloatToInt
edytuj#include <WinAPI.au3> _WinAPI_FloatToInt($nFloat)
Funkcja zamienia liczbę zmiennoprzecinkową (typ Float) na odpowiadającą jej 4-bajtową liczbę całkowitą (typ Integer).
$nFloat - liczba zmiennoprzecinkowa
Przykład:
#include <WinAPI.au3>
$float = 10.55
$INT = _WinAPI_FloatToInt($float)
$text = "Liczba zmiennoprzecinkowa " & $float & " przkonwertowano na liczbę całkowitą " & $INT & " (Hex = " & Hex($INT) & ")"
MsgBox(4096, "_WinAPI_FloatToInt", $text)
_WinAPI_IntToFloat
edytuj#include <WinAPI.au3> _WinAPI_IntToFloat($iInt)
Funkcja zamienia 4-bajtową liczbę całkowitą (typ Integer) na odpowiadającą jej liczbę zmiennoprzecinkową (typ Float). Jeżeli wystąpi błąd zwracany jest string "-1.#QNAN".
$nFloat - 4-bajtowa liczba całkowita
UWAGA: Funkcja nie zmienia typu liczby (jak np. funkcja Int()), lecz sposób interpretacji bitowego zapisu liczby w pamięci komputera.
Przykład:
#include <WinAPI.au3>
MsgBox(0, "", _WinAPI_IntToFloat(1000000))
_WinAPI_MakeLong
edytuj#include <WinAPI.au3> _WinAPI_MakeLong($iLo, $iHi)
Funkcja łączy dwa 2-bajtowe słowa w 4-bajtowe podwójne słowo.
$iLo - 2-bajtowe młodsze słowo
$iHi - 2-bajtowe starsze słowo
Przykład:
#include <WinAPI.au3>
$iWord = _WinAPI_MakeLong(0xaa, 0xbb)
MsgBox(4096, "_WinAPI_MakeLong", Hex($iWord))
_WinAPI_MakeQWord
edytuj#include <WinAPI.au3> _WinAPI_MakeQWord($LoDWORD, $HiDWORD)
Funkcja łączy dwa 4-bajtowe podwójne słowa w 8-bajtowe poczwórne słowo (Int64).
$LoDWORD - 4-bajtowe młodsze słowo
$HiDWORD - 4-bajtowe starsze słowo
Przykład:
#include <WinAPI.au3>
$iWord = _WinAPI_MakeQWord(0xaa, 0xbb)
MsgBox(4096, "_WinAPI_MakeQWord", Hex($iWord))
_WinAPI_MulDiv
edytuj#include <WinAPI.au3> _WinAPI_MulDiv($iNumber, $iNumerator, $iDenominator)
Funkcja mnoży dwie 32-bitowe liczby i dzieli 64-bitowy wynik przez trzecią 32-bitową liczbę. Zwraca wynik, lub -1 gdy wystąpił błąd.
Jeśli wynik nie jest liczbą całkowitą, jest zaokrąglany zgodnie z ogólnymi zasadami.
$iNumber i $iNumerator - dwie mnożone liczby
$iDenominator - liczba przez którą dzielimy
Przykład:
#include <WinAPI.au3>
MsgBox(0, '_WinAPI_MulDiv', _WinAPI_MulDiv(3, 8, 6) & ' = ' & 3 * 8 / 6)