AutoIt/WinAPI

Z Wikibooks, biblioteki wolnych podręczników.
Skocz do: nawigacja, szukaj

Spis treści

Co to jest WinAPI[edytuj]

Wg 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)[edytuj]

Niektó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)[edytuj]

Wszystkie 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)[edytuj]

Każ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[edytuj]

W 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:

  1. include <WinAPI.au3>
  2. 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 </source>


_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[edytuj]

Hak (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)