AutoIt/GUI

Z Wikibooks, biblioteki wolnych podręczników.
Przejdź do nawigacji Przejdź do wyszukiwania
Autoit GUI.jpg

Spis treści

Co to jest GUI?[edytuj]

GUI - graficzny interfejs użytkownika (ang. Graphical User Interface)

AutoIt umożliwia tworzenie w prosty sposób GUI w oparciu o system kontrolek. Obiekty te zdefiniowane są w systemie operacyjnym, a funkcje AutoIt'a mają za zadanie ich wywołanie, przekazanie do nich niezbędnych parametrów i odczytanie zwracanych przez nie odpowiedzi.

GUI jest sterowany zdarzeniami tzn. monitoruje kontrolki i reaguje na ich użycie. Za pomącą odpowiednich funkcji można odczytać stan kontrolek i w zależności od niego pokierować wykonaniem skryptu.

W zasadzie niektóre elementy GUI poznaliśmy przy okazji omawiania wyskakujących okienek. Funkcja MsgBox tworzy właśnie proste GUI, z oknem zawierającym kontrolki (przyciski, etykietki, ikony). Funkcja to jednocześnie monitoruje GUI, odczytuje stan kontrolek i reaguje na działanie użytkownika.


Co to jest uchwyt?[edytuj]

Omówmy teraz bardzo ważne pojęcie jakim jest uchwyt. Będziemy z nim mieli do czynienia nie tylko podczas tworzenia i obsługi GUI, ale także podczas działania na plikach, obrazach, elementach graficznych i w wielu innych przypadkach.

Co to więc jest ten uchwyt i dlaczego jest tak ważny?

Uchwyt (ang. handle) – to liczbowy (czterobajtowy) identyfikator różnych obiektów systemu Windows. Identyfikatory te są unikatowe, tzn. każdy obiekt ma inny uchwyt. Znając więc uchwyt można jednoznacznie zidentyfikować obiekt, którego on dotyczy.

Uchwyty identyfikują okna, kontrolki, bitmapy, ikony, pliki, różne obiekty graficzne. Dla przykładu wszystkie funkcje tworzące elementy GUI (okna i kontrolki) zwracają uchwyty do nich. Dzięki temu łatwo można odwoływać się do nich i zidentyfikować których elementów GUI dotyczą konkretne zdarzenia.


Kontrolki GUI - prezentacja[edytuj]

Kontrolki są podstawowy elementem graficznego interfejsu użytkownika (np. okno, pole edycji, suwak, przycisk itp.), umożliwiającym komunikację programu z użytkownikiem. Otrzymują one komunikaty generowane przez mysz i klawiaturę oraz inne komunikaty systemowe i wyświetlają swoją reprezentację na ekranie.

Poniższy skrypt ma za zadanie zaprezentowanie wszystkich dostępnych kontrolek. Po uruchomieniu na ekranie pokaże się okno jak na ilustracji obok (dla W7).

 
#include <GUIConstantsEx.au3>                  ;dołączenie do skryptu plików z definicjami stałych globalnych
#include <AVIConstants.au3>                    ;używanych jako parametr w niektórych funkcjach
#include <TreeViewConstants.au3>               ;do tworzenia GUI

;GUI - okno główne
GUICreate("Kontrolki GUI", 400, 600)                ;utworzenie okna głównego
GUISetIcon(@SystemDir & "\mspaint.exe", 0)          ;wczytanie ikony wyświetlanej na pasku zadań i belce okna

;AVI - okienko z animacją AVI
GUICtrlCreateAvi(@SystemDir & "\shell32.dll",165, 160, 00, 64, 64, $ACS_AUTOPLAY)

;BUTTON - przycisk
GUICtrlCreateButton("Przycisk", 10, 340, 100, 30)

;CHECKBOX - pole wyboru
GUICtrlCreateCheckbox("Zaznacz", 130, 345, 80, 20)
GUICtrlSetState(-1, $GUI_CHECKED)                   ;domyślnie pole odhaczone

;COMBO - lista rozwijana
GUICtrlCreatecombo("COMBO", 250, 80, 120, 100)      ;pierwsza pozycja listy COMBO
GUICtrlSetData(-1, "Pozycja 2|Pozycja 3|Pozycja 4") ;kolejne pozycje

;CONTEXT MENU - menu kontekstowe, dostępne po wciśnięciu prawego klawisza myszki
$contextMenu = GUICtrlCreateContextMenu()
GUICtrlCreateMenuItem("Menu kontekstowe", $contextMenu)
GUICtrlCreateMenuItem("", $contextMenu)                  ;separator
GUICtrlCreateMenuItem("Własciwosci", $contextMenu)

;DATE - kalendarz
GUICtrlCreateDate("", 5, 280, 200, 20)
GUICtrlCreateLabel("Kalendarz typ DATE", 10, 305, 200, 20)

;EDIT - pole edycyjne (mini edytor tekstu)
GUICtrlCreateEdit(" Pole edycyjne", 10, 110, 150, 70)

;GRAPHIC - okno grafiki
GUICtrlCreateGraphic(10, 400, 200, 170)
GUICtrlSetGraphic(-1, $GUI_GR_COLOR, 0x000000, 0xffffff)
GUICtrlSetGraphic(-1, $GUI_GR_RECT, 0, 0, 200, 170)
GUICtrlSetGraphic(-1, $GUI_GR_COLOR, 0xff0000, 0x88ff88)
GUICtrlSetGraphic(-1, $GUI_GR_ELLIPSE, 20, 60, 160, 40)
GUICtrlCreateLabel("Okno grafiki", 15, 385, 100, 15)

;GROUP WITH RADIO BUTTONS - grupa przełączników, aktywny tylko jeden przełącznik w grupie
GUICtrlCreateGroup("Grupa przełączników", 225, 120,120,90)
GUICtrlCreateRadio("Przełącznik 1", 245, 140, 80)
GUICtrlSetState(-1, $GUI_CHECKED)                   ;uaktywnienie przełącznika
GUICtrlCreateRadio("Przełącznik 2", 245, 160, 80)
GUICtrlCreateRadio("Przełącznik 3", 245, 180, 80)

GUICtrlCreateGroup ("",-99,-99,1,1)                 ;koniec grupy

;ICON - ikona
GUICtrlCreateIcon("shell32.dll", 13, 175, 120)
GUICtrlCreateLabel("Ikona", 180, 160, 50, 20)

;INPUT - okienko wprowadzania
GUICtrlCreateInput("Okienko wprowadzania", 235, 255, 130, 20)

;LABEL - etykietka
GUICtrlCreateLabel(" Zielona" & @LF & "etykietka", 350, 165, 45, 40)
GUICtrlSetBkColor(-1, 0x00ff00)                     ;ustawienie koloru tła na zielony

;LIST - lista
GUICtrlCreateList("", 5, 190, 100, 90)
GUICtrlSetData(-1, "1. To|2. Jest|3. Lista|4. Wyboru", "2. Jest")

;LIST VIEW - tabela
$listView = GUICtrlCreateListView("Poz.|Tabela|", 110, 190, 115, 85)
GUICtrlCreateListViewItem("A|Jeden", $listView)
GUICtrlCreateListViewItem("B|Dwa", $listView)
GUICtrlCreateListViewItem("C|Trzy", $listView)

;MENU - menu rozwijane
$Menu1=GUICtrlCreateMenu("Menu 1")
GUICtrlCreateMenuItem("Opcja 1", $Menu1)
GUICtrlCreateMenuItem("", $Menu1)                      ;separator
GUICtrlCreateMenuItem("&Opcja 2", $Menu1)
$Menu2=GUICtrlCreateMenu("Menu 2")
GUICtrlCreateMenuItem("Ustawienie 1", $Menu2)
GUICtrlSetState(-1, $GUI_CHECKED)
GuiCtrlCreateMenuItem("", $Menu2)                      ;separator
GuiCtrlCreateMenuItem("Ustawienie 2", $Menu2)
GUICtrlSetState(-1, $GUI_CHECKED)
$Menu3=GuiCtrlCreateMenu("Menu 3")
GUICtrlSetState(-1, $GUI_CHECKED)
$Menu31=GUICtrlCreateMenu("Wybór 1", $Menu3,1)         ;pod-menu
GUICtrlCreateMenuItem("To", $Menu31)
GUICtrlCreateMenuItem("Tamto", $Menu31)

;MONTH CALL - kalendarz
GUICtrlCreateMonthCal("", 220, 400,158,163)
GUICtrlCreateLabel("Kalendarz typ MONTH CALL", 225, 385, 150, 15)

;PIC - obrazek
GUICtrlCreatePic(@windowsDir&"\Web\Wallpaper\Windows\img0.jpg",20,0, 130,68)

;PROGRESS - pasek postępu
GUICtrlCreateProgress(60, 80, 150, 20)
GUICtrlSetData(-1, 60)
GUICtrlCreateLabel("Pasek"&@LF&"postępu:", 5, 75)

;SLIDER - suwak
GUICtrlCreateLabel("Suwak:", 235, 215)
GUICtrlCreateSlider(270, 210, 120, 30)
GUICtrlSetData(-1, 30)                    ;początkowe położenie suwaka

;TAB - zakładka
GUICtrlCreateTab(240, 0, 150, 70)
GUICtrlCreateTabItem("Jeden")
GUICtrlCreateLabel("Zakładka JEDEN", 250, 40)
GuiCtrlCreateTabItem("Dwa")
GUICtrlCreateLabel("Zakładka DWA", 275, 40)
GUICtrlCreateTabItem("Trzy")
GUICtrlCreateLabel("Zakładka TRZY", 300, 40)
GUICtrlCreateTabItem("")

;TREEVIEW ONE - drzewo wersja 1
$treeOne=GUICtrlCreateTreeView(210, 290, 100, 80)
$treeItem=GUICtrlCreateTreeViewItem("Drzewo 1", $treeOne)
GUICtrlCreateTreeViewItem("Poz.1", $treeItem)
GUICtrlCreateTreeViewItem("Poz.2", $treeItem)
GUICtrlCreateTreeViewItem("Poz.3", -1)
GUICtrlSetState($treeItem, $GUI_EXPAND)

;TREEVIEW TWO - drzewo wersja 2
$treeTwo=GUICtrlCreateTreeView(315, 290, 80, 80, $TVS_CHECKBOXES)
GUICtrlCreateTreeViewItem("Drzewo 2", $treeTwo)
GUICtrlCreateTreeViewItem("z", $treeTwo)
GUICtrlCreateTreeViewItem("polami", $treeTwo)
GUICtrlSetState(-1, $GUI_CHECKED)                ;pole odhaczone
GUICtrlCreateTreeViewItem("wyboru", $treeTwo)

;UPDOWN - góra / dół
GUICtrlCreateLabel("Góra/dół", 355, 115)
GUICtrlCreateInput("666", 345, 130, 50, 20)      ;ustawienie wartości startowej
GUICtrlCreateUpDown(-1)


;pętla, czeka na naciśnięcie przycisku zamknięcia okna, co zakończy działanie skryptu
GUISetState()                      ;wyświetlenie na ekranie przygotowanego powyżej GUI
While GUIGetMsg() <> $GUI_EVENT_CLOSE
WEnd


Tworzymy okno GUI[edytuj]

Wiemy już co to jest GUI i z jakich elementów się składa. Teraz zajmiemy się tworzeniem GUI od podstaw, a podstawą jest okno, w którym można rozmieszczać kontrolki. Utworzymy okno o wymiarach 400x600 pikseli znajdujące się (domyślnie) na środku ekranu.

GUICreate("Kontrolki GUI", 400, 600)

Tak utworzone okno nie będzie jednak widoczne na ekranie, gdyż domyślnie jest ono ukryte.

Aby utworzone okno pokazać na ekranie należy użyć funkcji GUISetState

Moglibyśmy uzupełnić nasz przykład do postaci:

GUICreate("Kontrolki GUI", 400, 600)
GUISetState()

Teraz okno pokaże się na ekranie, ale tylko na ułamek sekundy, gdyż za chwilę skrypt zakończy działanie.

Należy więc dodać pętlę, ale żeby możliwe było jej opuszczenie trzeba określić warunek zamknięcia okna. Standardowo do zamknięcia okna służy przycisk z krzyżykiem w prawym górnym jego narożniku.

Jak się jednak dowiedzieć, że został on użyty? Należy posłużyć się funkcją GUIGetMsg:

Teraz nareszcie możemy napisać w pełni funkcjonalny szkielet naszego GUI:

#include <GUIConstantsEx.au3>

GUICreate("Kontrolki GUI", 400, 600)
GUISetState()
While GuiGetMsg() <> $GUI_EVENT_CLOSE
WEnd

Skrypt wyświetli na ekranie puste okno wyposażone jedynie w podstawowe kontrolki do jego obsługi. Okienko ma standardowe ikonki na belce, na pasku zadań i w zasobniku systemowym.

Jeżeli chcemy mu przypisać inną ikonę to powinniśmy użyć funkcji GUISetIcon.

I jeszcze kilka funkcji wpływających na wygląd i zachowanie okna:

GUISetBkColor - zmaina koloru tła okna.

GUISetCursor - zmiana wyglądu kursora po najechaniu na okno.

GUISetHelp - określenie programu uruchamianego po wciśnięciu klawisza F1.

A teraz okienko z wszystkimi dodatkowymi elementami:

#include <GUIConstantsEx.au3>              ;plik z definicją stałych dotyczących GUI

GUICreate("Kontrolki GUI", 400, 600)       ;utworzenie okna
GUISetIcon(@SystemDir & "\mspaint.exe", 0) ;ustalenie nowej ikony
GUISetBkColor(0x00ff00)                    ;kod koloru
GUISetCursor(15)                           ;ustalenie nowego kursora
GUISetHelp("AutoIt3Help.exe")              ;ustalenie programu uruchamianego przez F1
GUISetState()                              ;wywołanie okna na ekran
While GUIGetMsg() <> $GUI_EVENT_CLOSE      ;SGUI_EVENT_CLOSE - stała zdefiniowana w GUIConstantsEx.au3
WEnd                                       ;oznacza, że wciśnięto przycisk zamknięcia okna

Dokładne wyjaśnienie poszczególnych parametrów funkcji w podrozdziale "Opis funkcji GUI".

Kontrolki GUI i ich obsługa[edytuj]

Stwórzmy teraz kompletny GUI wraz z kontrolkami i ich obsługą. Zrobimy to na przykładzie skryptu do przeliczania liczb binarnych na liczby w innych systemach liczbowych (ósemkowym, dziesiętnym i szesnastkowym). GUI skryptu powinien zawierać okienko do wyświetlania liczby binarnej, okienko do wyświetlania wyniku, dwa klawisze z cyframi binarnymi 0 i 1, klawisze do kasowania znaku i całej liczby binarnej oraz klawisz zamykający skrypt.

Przykładowy GUI może wyglądać tak:

#include <GUIConstantsEx.au3>

;tworzenie okna głównego
GUICreate("Przeliczanie liczb binarnych", 400, 300)
GUISetBkColor(0xbbbbbb)                               ;tło okna w kolorze ciemno szarym

;tworzenie kontrolek
GUICtrlCreateGroup ("", 95, 30, 255, 40)              ;wykorzystujemy funkcję do narysowania ramki
GUICtrlCreateGroup ("BIN", 95, 30, 216, 40)
$hLab1 = GUICtrlCreateLabel("0", 106, 46, 192, 15, 2) ;okienko na liczbę binarną, wyrównanie do prawej
GUICtrlSetBkColor(Default, 0xeeeeee)                  ;kolor tła okienka liczby binarnej
GUICtrlSetColor(Default, 0xff0000)                    ;kolor czcionki w okienku liczby binarnej
GUICtrlCreateGroup ("", 100, 135, 200, 40)            ;kolejna ramka
$hLab2 = GUICtrlCreateLabel("0", 120, 152, 160, 15,2)  ;okienko na wynik, wyrównanie do prawej
GUICtrlCreateGroup ("Przelicz na", 100, 85, 200, 50)  ;tworzymy grupę z trzech przełączników RADIO
$hRadio_oct = GUICtrlCreateRadio("OCT", 120, 105)
$hRadio_dec = GUICtrlCreateRadio("DEC", 180, 105)
GUICtrlSetState(-1, $GUI_CHECKED)                     ;ustawiamy status przełącznika "DEC" na zaznaczony
$hRadio_hex = GUICtrlCreateRadio("HEX", 240, 105)
$hButton_0 = GUICtrlCreateButton("0", 100, 190, 40, 40) ;kolejno wszystkie 5 klawiszy
$hButton_1 = GUICtrlCreateButton("1", 150, 190, 40, 40)
$hButton_back = GUICtrlCreateButton("<- Backspace", 200, 190, 100, 40)
$hButton_end = GUICtrlCreateButton("Koniec", 100, 245, 200, 25)
$hButton_clr = GUICtrlCreateButton("CLR", 312, 40, 34, 24)

GUISetState()             ;wywołanie GUI na ekran

;pętla obsługi GUI
While 1
   $msg = GUIGetMsg()               ;odczytanie zdarzenia jakie zaszło w GUI
   Switch $msg                      ;instrukcja warunkowa
      case $GUI_EVENT_CLOSE         ;jeżeli użyto przycisku zamknięcia okna
         ExitLoop                   ;to wyjście z pętli i koniec skryptu
   EndSwitch
WEnd

Mamy już kompletny GUI z wszystkimi zaplanowanymi kontrolkami, lecz brakuje nam jeszcze obsługi tych kontrolek. Jedyne co możemy w tej chwili zrobić to zakończyć skryptu przyciskiem zamknięcia okna.

Zauważmy, że dla każdej kontrolki zapamiętaliśmy jej uchwyt (w zmiennej). Dzięki temu będziemy mogli zidentyfikować kontrolkę, której dotyczy dane zdarzenie.

Najprościej będzie obsłużyć klawisz "Koniec", bo ma on działać tak jak przycisk zamknięcia okna. Wystarczy więc zamiast case $GUI_EVENT_CLOSE napisać case $GUI_EVENT_CLOSE, $hButton_end.

Jeżeli założymy, że liczbę binarną będziemy przechowywać w zmiennej tekstowej to klawisze:

"0" i "1" - dodają na końcu łańcucha znak 0 lub 1 (np. $sStrBin&="0")

"Backspace" - usuwa ostatni znak (np. StringTrimRight($sStrBin,1)

"CLR" - usuwa wszystkie znaki zastępując je zerem (np. $sStrBin="0")

Poniżej w pełni funkcjonalny skrypt:

#include <GUIConstantsEx.au3>

;tworzenie okna głównego
GUICreate("Przeliczanie liczb binarnych", 400, 300)
GUISetBkColor(0xbbbbbb)                               ;tło okna w kolorze ciemno szarym

;tworzenie kontrolek
GUICtrlCreateGroup ("", 95, 30, 255, 40)              ;wykorzystujemy funkcję do narysowania ramki
GUICtrlCreateGroup ("BIN", 95, 30, 216, 40)
$hLab1 = GUICtrlCreateLabel("0", 106, 46, 192, 15, 2) ;okienko na liczbę binarną, wyrównanie do prawej
GUICtrlSetBkColor(Default, 0xeeeeee)                  ;kolor tła okienka liczby binarnej
GUICtrlSetColor(Default, 0xff0000)                    ;kolor czcionki w okienku liczby binarnej
GUICtrlCreateGroup ("", 100, 135, 200, 40)            ;kolejna ramka
$hLab2 = GUICtrlCreateLabel("0", 120, 152, 160, 15,2)  ;okienko na wynik, wyrównanie do prawej
GUICtrlCreateGroup ("Przelicz na", 100, 85, 200, 50)  ;tworzymy grupę z trzech przełączników RADIO
$hRadio_oct = GUICtrlCreateRadio("OCT", 120, 105)
$hRadio_dec = GUICtrlCreateRadio("DEC", 180, 105)
GUICtrlSetState(-1, $GUI_CHECKED)                     ;ustawiamy status przełącznika "DEC" na zaznaczony
$hRadio_hex = GUICtrlCreateRadio("HEX", 240, 105)
$hButton_0 = GUICtrlCreateButton("0", 100, 190, 40, 40) ;kolejno wszystkie 5 klawiszy
$hButton_1 = GUICtrlCreateButton("1", 150, 190, 40, 40)
$hButton_back = GUICtrlCreateButton("<- Backspace", 200, 190, 100, 40)
$hButton_end = GUICtrlCreateButton("Koniec", 100, 245, 200, 25)
$hButton_clr = GUICtrlCreateButton("CLR", 312, 40, 34, 24)

GUISetState()          ;wywołanie GUI na ekran
$sStrBin="0"           ;deklaracja zmiennej przechowującej liczbę binarną

While 1                ;pętla obsługi GUI
   $msg = GUIGetMsg()  ;odczytanie ID zdarzenia jakie zaszło w GUI
   Switch $msg
      case $GUI_EVENT_CLOSE, $hButton_end
         ExitLoop
      case $hButton_0
         If StringLen($sStrBin)<31 Then $sStrBin &= "0"       ;ograniczenie liczby binarnej do 31 cyfr
         ;wykorzystujemy wyrażenie regularne do pozbycia się zer na początku liczby binarnej
         $sStrBin = StringRegExpReplace($sStrBin, "^0*(.+)$", "$1")
         GUICtrlSetData($hLab1, $sStrBin)               ;aktualizacja danych w okienku liczby binarnej
      case $hButton_1
         If StringLen($sStrBin)<31 Then $sStrBin &= "1"
         $sStrBin = StringRegExpReplace($sStrBin, "^0*(.+)$","$1")
         GUICtrlSetData($hLab1, $sStrBin)
      case $hButton_back
         If $sStrBin<>"0" Then $sStrBin = StringTrimRight($sStrBin, 1)
         GUICtrlSetData($hLab1, $sStrBin)
      case $hButton_clr
         $sStrBin = " 0"
         GUICtrlSetData($hLab1, $sStrBin)
   EndSwitch
   If $msg<>0 Then
      $iPar =  (GUICtrlRead($hRadio_oct)=$GUI_CHECKED)
      $iPar += (GUICtrlRead($hRadio_dec)=$GUI_CHECKED)*2
      $iPar += (GUICtrlRead($hRadio_hex)=$GUI_CHECKED)*4
      GUICtrlSetData($hLab2, oblicz($iPar, $sStrBin))         ;aktualizacja danych w okienku wyników
   endif
WEnd


;funkcja przeliczająca liczby w zapisie binarnym na liczby ósemkowe, dziesiętne lub szesnastkowe
;do zamiany liczby dwójkowej na dziesiętną piszemy własną procedurę (między For ... Next)
;gdyż w AutoIt nie ma stosownej funkcji
;do zamiany liczby dziesiętnej na ósemkową i szesnastkową wykorzystujemy funkcję formatującą
;StringFormat (opis w rozdziale "Napisy (stringi)")

Func oblicz($iP,$sSbin)
   Local $iLen=StringLen($sSbin), $iLicz=0, $i, $j, $a
   ;zmiana liczby dwójkowej na dziesiętną
   For $i=$iLen to 1 Step -1
      $j = $iLen-$i
      $a = StringMid($sSbin, $i, 1)
      $iLicz += Number($a)*2^$j
   Next
   Switch $iP
      case 1
         Return StringFormat("%o",$iLicz) ;zmiana na liczbę ósemkową
      case 2
         Return $iLicz
      case 4
         Return StringFormat("%X",$iLicz) ;zmiana na liczbę szesnastkową
   EndSwitch
EndFunc

O nazwach funkcji GUI[edytuj]

Ponieważ ilość funkcji do obsługi GUI jest ogromna, aby łatwiej się w nich orientować warto chwilę czasu poświęcić na zapoznanie się z ideą tworzenia ich nazw.

Wszystkie funkcje odnoszące się do całego GUI (przede wszystkim do okna głównego) rozpoczynają się od "GUI", dalsza część nazwy opisuje działanie funkcji np.:

FUNKCJE ODNOSZĄCE SIĘ DO CAŁEGO GUI LUB DO OKNA GŁÓWNEGO
--------------------------------------------------------
GUI...
GUICreate          - tworzenie okna GUI
GUIDelete          - likwidowanie GUI
GUIRegisterMsg     - ustalenie jaka funkcja użytkownika ma być wywołana, w odpowiedzi na określony komunikat systemowy okna
GUIStartGroup      - początek definicji grupy kontrolek
GUISwitch          - przełącznik bieżącego okna GUI (jeżeli mamy przygotowane kilka okien GUI)

GUIGet...  - grupa funkcji do odczytu parametrów lub stanu GUI
GUIGetCursorInfo   - zwraca położenie kursora myszki, stan klawiszy i ID kontrolki nad którą znajduje się kursor
GUIGetMsg          - odczytanie identyfikatora (ID) zdarzenia lub uchwytu do użytej kontrolki
GUIGetStyle        - odczytanie stylu okna GUI

GUISet...  - grupa funkcji do ustawiania parametrów GUI
GUISetAccelerators - definiowanie skrótów klawiszowych aktywnych w GUI
GUISetBkColor      - ustawienie koloru tła okna GUI
GUISetCoord        - ustawienie współrzędnych bezwzględnych dla następnych kontrolek
GUISetCursor       - ustalenie wyglądu kursora wewnątrz GUI
GUISetFont         - ustawienie bieżącej czcionki
GUISetHelp         - ustalenie programu uruchamianego po wciśnięciu klawisza F1 (używane do wywoływania pliku pomocy)
GUISetIcon         - ustalenie ikony wyświetlanej na belce okna i pasku zadań
GUISetOnEvent      - ustalenie jaka funkcja użytkownika ma być wywołana, po wciśnięciu jakiegoś przycisku systemowego okna
GUISetState        - ustalenie statusu okna (widoczne, niewidoczne, zminimalizowane itp.)
GUISetStyle        - ustawienie stylu okna

Wszystkie funkcje odnoszące się do kontrolek rozpoczynają się od "GUICrtl", dalsza część nazwy opisuje działanie funkcji np.:

FUNKCJE ODNOSZĄCE SIĘ DO KONTROLEK GUI
--------------------------------------
GUICtrl...
GUICtrlDelete               - usunięcie kontrolki
GUICtrlRead                 - odczyt danych z kontrolki lub jej statusu 
GUICtrlRegisterListViewSort -
GUICtrlSendMsg              - przesłanie komunikatu do kontrolki
GUICtrlRecvMsg              - przesłanie komunikatu do kontrolki
GUICtrlSendToDummy          - symulacja użycia atrapy kontrolki

GUICtrlCreate...  - grupa funkcji do tworzenie kontrolek
GUICtrlCreateAvi          - animacja AVI
GUICtrlCreateButton       - przycisk z nazwą
GUICtrlCreateCheckbox     - pole wyboru (CHECKBOX)
GUICtrlCreateCombo        - lista rozwijana (COMBO)
GUICtrlCreateContextMenu  - menu kontekstowe
GUICtrlCreateDate         - kalendarz
GUICtrlCreateDummy        - tworzenie atrapy kontrolki
GUICtrlCreateEdit         - pole edycyjne (mini edytor tekstu)
GUICtrlCreateGraphic      - okno grafiki
GUICtrlCreateGroup        - tworzenie grupy kontrolek łącznie z rysowaniem ramki
GUICtrlCreateIcon         - ikona
GUICtrlCreateInput        - okienko wprowadzania
GUICtrlCreateLabel        - etykietka
GUICtrlCreateList         - lista
GUICtrlCreateListView     - tabela
GUICtrlCreateListViewItem - tworzenie elementu tabeli
GUICtrlCreateMenu         - menu rozwijane
GUICtrlCreateMenuItem     - pozycje menu rozwijanego lub kontekstowego
GUICtrlCreateMonthCal     - kalendarz
GUICtrlCreatePic          - obrazek
GUICtrlCreateProgress     - pasek postępu
GUICtrlCreateRadio        - przełącznik (zwykle występuje w grupie)
GUICtrlCreateSlider       - suwak
GUICtrlCreateTab          - zakładka
GUICtrlCreateTabItem      - kolejne pozycje zakładki
GUICtrlCreateTreeView     - drzewo
GUICtrlCreateTreeViewItem - kolejne gałęzie drzewa
GUICtrlCreateUpdown       - przyciski "góra/dół"

GUICtrlGet...  - grupa funkcji do odczytu stanu kontrolki
GUICtrlGetHandle          - odczyt uchwytu kontrolki
GUICtrlGetState           - odczyt statusu kontrolki

GUICtrlSet...  - grupa funkcji do ustawiania stanu kontrolki
GUICtrlSetBkColor         - ustawienie koloru tła (dla pojedynczej kontrolki)
GUICtrlSetColor           - ustawienie koloru tekstu (dla pojedynczej kontrolki)
GUICtrlSetCursor          - ustwienie wyglądu kursora po najechaniu na kontrolkę
GUICtrlSetData            - wprowadzenie danych do kontrolki
GUICtrlSetDefBkColor      - ustawienie koloru tła (dla wszystkich następnych kontrolek)
GUICtrlSetDefColor        - ustawienie koloru tekstu (dla wszystkich następnych kontrolek)
GUICtrlSetFont            - ustawienie bieżącej czcionki
GUICtrlSetGraphic         - rysowanie w okienku graficznym
GUICtrlSetImage           - wstawienie do kontrolki bitmapy (PIC) lub ikony  (BUTTON, ICON)
GUICtrlSetLimit           - ustalenie maksymalnej i minimalnej wielkości danych w kontrolce
GUICtrlSetOnEvent         - ustalenie jaka funkcja użytkownika ma być wywołana jeżeli zostanie kliknięta kontrolka
GUICtrlSetPos             - ustawienie położenia kontrolki w oknie GUI
GUICtrlSetResizing        - ustalenie sposobu reagowania kontrolek na zmianę wielkości okna GUI
GUICtrlSetState           - ustawienie statusu kontrolki
GUICtrlSetStyle           - ustawienie stylu wyglądu kontrolki
GUICtrlSetTip             - tworzenie etykietki ukazującej się po najechaniu na kontrolkę

Opis funkcji GUI[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.


Tworzenie okna GUI[edytuj]

GUICreate ( "nazwa" [, szerokość [, wysokość [, x [, y [, style [, exstyle [, hwnd]]]]]]] )

Funkcja zwraca uchwyt do utworzonego okna, lub 0 gdy wystąpił błąd (dodatkowo makro @error przyjmuje wtedy wartość 1).

"nazwa" - nazwa okna wyświetlana na jego belce.

Pozostałe parametry są opcjonalne:

szerokość i wysokość to szerokość i wysokość tworzonego okna (w pikselach).

x i y - położenie w pikselach lewego górnego narożnika okna w stosunku do współrzędnych ekranu (domyślnie okno na środku ekranu).

style i exstyle to parametry określające wygląd tworzonego okna. Aby uzyskać wartości domyślne należy wpisać -1 lub Default.

hwnd - uchwyt do okna nadrzędnego, jeżeli tworzymy okno potomne

style (nazwy wg <WindowsConstants.au3>)
---------------------------------------------------------------------------
$WS_TILED       |          0 | okno z paskiem tytułowym i ramką
---------------------------------------------------------------------------
$WS_MAXIMIZEBOX | 0x00010000 | okno z przyciskiem maksymalizacji
---------------------------------------------------------------------------
$WS_MINIMIZEBOX | 0x00020000 | okno z przyciskiem minimalizacji
---------------------------------------------------------------------------
$WS_SIZEBOX     | 0x00040000 | okno z możliwością zmiany wymiarów
---------------------------------------------------------------------------
$WS_SYSMENU     | 0x00080000 | okno z ikoną i przyciskiem zamknięcia
---------------------------------------------------------------------------
$WS_HSCROLL     | 0x00100000 | suwak poziomy
---------------------------------------------------------------------------
$WS_VSCROLL     | 0x00200000 | suwak pionowy 
---------------------------------------------------------------------------
$WS_DLGFRAME    | 0x00400000 | cieniowana ramka wokół okna
---------------------------------------------------------------------------
$WS_BORDER      | 0x00800000 | pojedyncza ramka wokół okna
---------------------------------------------------------------------------
$WS_CAPTION     | 0x00C00000 | okno z belką, bez przycisków i ikony
---------------------------------------------------------------------------
$WS_TILEDWINDOW | 0x00CF0000 | wszystkie przyciski i zmiana wymiarów
                |            | kombinacja stylów WS_TILED, WS_CAPTION,
                |            | WS_SYSMENU, WS_MINIMIZEBOX, WS_MAXIMIZEBOX
---------------------------------------------------------------------------
$WS_MAXIMIZE    | 0x01000000 | okno zmaksymalizowane
---------------------------------------------------------------------------
$WS_CLIPCHILDREN| 0x02000000 | wyklucza obszary okien potomnych podczas 
                |            | rysowania w oknie głównym, 
                |            | w przeciwnym wypadku system pozwala rodzicowi 
                |            | rysować w oknach potomnych,
                |            | używa się przy tworzenia okna głównego
---------------------------------------------------------------------------
$WS_CLIPSIBLINGS| 0x04000000 | wyklucza obszary okien potomnych podczas 
                |            | rysowania w innym oknie potomnym, 
                |            | jeżeli okna potomne zachodzą na siebie
                |            | uniemożliwia malowanie w obszarze zajętym
                |            | także przez inne okno potomne
---------------------------------------------------------------------------
$WS_DISABLED    | 0x08000000 | okno nieaktywne
---------------------------------------------------------------------------
$WS_VISIBLE     | 0x10000000 | okno automatycznie widoczne po utworzeniu
---------------------------------------------------------------------------
$WS_MINIMIZE    | 0x20000000 | okno zminimalizowane
---------------------------------------------------------------------------
$WS_CHILD       | 0x40000000 | okno potomne, nie może mieć belki 
---------------------------------------------------------------------------
$WS_POPUP       | 0x80000000 | styl popup, puste okno
---------------------------------------------------------------------------
$WS_POPUPWINDOW | 0x80880000 | styl popup, puste okno z pojedynczą ramką
                |            | kombinacja WS_BORDER, WS_POPUP, WS_SYSMENU
---------------------------------------------------------------------------
Domyślna wartość to kombinacja stylów:
$WS_MINIMIZEBOX, $WS_CAPTION, $WS_POPUP i $WS_SYSMENU.

Niektóre style można sumować (bitowo), np.:
BitOr($WS_TILEDWINDOW, $WS_HSCROLL, $WS_VSCROLL)
BitOr($WS_POPUP, $WS_DLGFRAME)
--------------------------------------------------------------------------------
exstyle (nazwy wg <WindowsConstants.au3>)
--------------------------------------------------------------------------------
$WS_EX_DLGMODALFRAME| 0x000001 | obramowanie wypukłe
--------------------------------------------------------------------------------
$WS_EX_ACCEPTFILES  | 0x000010 | akceptuje pobieranie nazw plików drag&drop
--------------------------------------------------------------------------------
$WS_EX_TRANSPARENT  | 0x000020 | okno jest przeźroczyste, tzn. nie zasłania 
                    |          | okien znajdujących się pod nim
--------------------------------------------------------------------------------
$WS_EX_MDICHILD     | 0x000040 | okna potomnego wewnątrz okna rodzica
--------------------------------------------------------------------------------
$WS_EX_TOPMOST      | 0x000008 | okno zawsze na wierzchu, nawet nieaktywne
--------------------------------------------------------------------------------
$WS_EX_TOOLWINDOW   | 0x000080 | styl okienka narzędziowego, bez ikony na belce,
                    |          | belka wąska, tylko przycisk zamknięcia okna
--------------------------------------------------------------------------------
$WS_EX_WINDOWEDGE   | 0x000100 | okno ma ramkę z podniesionym brzegiem
--------------------------------------------------------------------------------
$WS_EX_CLIENTEDGE   | 0x000200 | obramowanie wklęsłe
--------------------------------------------------------------------------------
$WS_EX_CONTEXTHELP  | 0x000400 | znak zapytania przy przycisku zamknięcia okna,
                    |          | działa tylko ze stylami mającymi jedynie 
                    |          | przycisk zamknięcia okna
--------------------------------------------------------------------------------
$WS_EX_CONTROLPARENT| 0x010000 | umożliwia przełączanie między oknami-dziećmi 
                    |          | danego okna za pomocą klawisza TAB
--------------------------------------------------------------------------------
$WS_EX_STATICEDGE   | 0x020000 | obramowanie 3D
--------------------------------------------------------------------------------
$WS_EX_LAYERED      | 0x080000 | tworzy okno warstwowe, stosuje się np.
                    |          | gdy chcemy nadać przezroczystość jakiejś
                    |          | warstwie (kolorowi) okna,
                    |          | nie należy stosować do okien potomnych
--------------------------------------------------------------------------------
$WS_EX_LAYOUTRTL    | 0x400000 | układ elementów okna w lustrzanym odbiciu
-------------------------------------------------------------------------------- 
WS_EX_DLGMODALFRAME, WS_EX_CLIENTEDGE, WS_EX_STATICEDGE - tylko dla okna
w stylu WS_POPUP lub WS_POPUPWINDOW.

WS_EX_CONTEXTHELP nie należy stosować ze stylami WS_MAXIMIZEBOX i WS_MINIMIZEBOX.

Niektóre wartości można sumować, np.: 0x88 oznacza okno w stylu narzędziowym,
z atrybutem "zawsze na wierzchu".

Przykład:

#include <GUIConstantsEx.au3>
#include <WindowsConstants.au3>

GUICreate("Okno główne", 400, 600, 400, 300, BitOr($WS_TILEDWINDOW, $WS_VSCROLL))
GUISetState()
Do
Until GUIGetMsg()=$GUI_EVENT_CLOSE

Przykład z oknem potomnym (skalowane z suwakiem):

#include <GUIConstantsEx.au3>
#include <WindowsConstants.au3>

$hGUI = GUICreate ("Test" , 600 , 600)
$iStyle = BitOR($WS_CHILD, $WS_VSCROLL, $WS_SIZEBOX)
$hCh = GUICreate("", 300, 240, 100,100, $iStyle, -1, $hGUI)
GUISetBkColor(0xff0000)
GUISetState(@SW_SHOW ,$hGUI)
GUISetState(@SW_SHOW ,$hCh)
Do
Until GUIGetMsg()=$GUI_EVENT_CLOSE

Zlikwidowanie GUI[edytuj]

GUIDelete ( [uchwyt] )

Funkcja zwraca 1 gdy sukces, 0 gdy wystąpił błąd.

uchwyt - uchwyt do okna GUI, które ma być zlikwidowane (domyślnie okno bieżące).

Należy podać gdy mamy przygotowane kilka GUI, a funkcja ma dotyczyć innego GUI niż bieżące.


Ustalenie (rejestrowanie) jaka funkcja użytkownika ma być wywołana, w odpowiedzi na określony komunikat systemowy okna[edytuj]

GUIRegisterMsg ( msgID, "funkcja" )

Funkcja zwraca 1 gdy sukces lub 0 gdy wystąpi błąd.

Parametry:

msgID - ID komunikatu systemowego (patrz plik pomocy AutoIt)

"funkcja" - nazwa rejestrowanej funkcji, string pusty "" oznacza wyrejestrowanie (powrót do stanu wyjściowego)

UWAGA:

Zdefiniowana funkcja użytkownika może mieć najwyżej 4 parametry. Dwa pierwsze to kolejno: uchwyt do GUI i ID komunikatu systemowego. Pozostałe dwa dowolne liczby szesnastkowe.

Można zarejestrować do 256 funkcji użytkownika.

Przykład:

#include <GUIConstantsEx.au3>

$hHandle = GUICreate("Test myszki", 400, 280)
;rejestracja funkcji użytkownika
GUIRegisterMsg ( 0x20A, "my" )
GUIRegisterMsg ( 0x203, "my" )
GUIRegisterMsg ( 0x003, "my" )
GUISetState()
Do
Until GUIGetMsg()=$GUI_EVENT_CLOSE

;definiowanie funkcji użytkownika do obsługi komunikatów systemowych
Func my($hHandle, $iID)
   Switch $ID
      Case 0x20A
         ToolTip("Obrót rolki")
         Sleep(200)
         ToolTip("")
      Case 0x203
         ToolTip("Podwójne kliknięcie")
         Sleep(1000)
         ToolTip("")
      Case 0x003
         ToolTip("Przesuwanie okna")
         Sleep(30)
         ToolTip("")
   EndSwitch
EndFunc


Początek definicji grupy kontrolek[edytuj]

GUIStartGroup ( [uchwyt] )

Funkcja zwraca 1 gdy sukces, 0 gdy wystąpił błąd.

uchwyt - uchwyt okna do którego ma się odnosić ta funkcja (należy podać gdy mamy większą ilość utworzonych okien, a funkcja nie dotyczy okna bieżącego, w przeciwnym wypadku parametr można pominąć).

Funkcja ta jest zazwyczaj używana podczas pracy z kontrolkami RADIO. Po kliknięciu przycisku RADIO wszystkich innych przycisków w tej samej grupy są resetowane. Funkcja GUIStartGroup umożliwia zdefiniowanie grupy.

Przykład:

#include <GUIConstantsEx.au3>

GUICreate("Tworzenie grup kontrolek", 400, 280)

;tworzonie kontrolek
$hButton_1 = GUICtrlCreateButton("Przy&cisk", 30, 20, 120, 40)
$hGroup_1 = GUICtrlCreateGroup("Group 1", 30, 90, 165, 160)   ;ramka
GUIStartGroup()
$HRadio_1 = GUICtrlCreateRadio("Radio &0", 50, 120, 70, 20)
$hRadio_2 = GUICtrlCreateRadio("Radio &1", 50, 150, 60, 20)
$hRadio_3 = GUICtrlCreateRadio("Radio &2", 50, 180, 60, 20)
GUIStartGroup()
$hRadio_4 = GUICtrlCreateRadio("Radio &A", 120, 120, 70, 20)
$hRadio_5 = GUICtrlCreateRadio("Radio &B", 120, 150, 60, 20)
$hRadio_6 = GUICtrlCreateRadio("Radio &C", 120, 180, 60, 20)
GUIStartGroup()
$hInput_1 = GUICtrlCreateInput("Input 1", 200, 20, 160, 30)
$hInput_2 = GUICtrlCreateInput("Input 2", 200, 70, 160, 30)

;ustawianie przełączników aktywnych
GUICtrlSetState($hRadio_1, $GUI_CHECKED)
GUICtrlSetState($hRadio_6, $GUI_CHECKED)
GUICtrlSetState($hButton_1, $GUI_FOCUS + $GUI_DEFBUTTON)

GUISetState()

Do
Until GUIGetMsg()=$GUI_EVENT_CLOSE


Przełączanie bieżącego GUI[edytuj]

GUISwitch ( uchwyt [, tabitemID] )

Funkcja umożliwia przełączanie między kilkoma przygotowanymi wcześniej GUI.

Zwraca uchwyt do bieżącego okna lub 0 gdy wystąpił błąd.

tabitemID - parametr opcjonalny określający, która zakładka w menu zakładek ma być aktywna (oczywiście gdy takie menu w GUI istnieje).

UWAGA: Funkcja nie wywołuje automatycznie okna na ekran, ani nie uaktywnia go.

Przykład:

#include <GUIConstantsEx.au3>

$hGUI_1 = GUICreate("GUI_1")             ;tworzenie GUI_1
GUICtrlCreateTab(10, 10,200)
GUICtrlCreateTabItem("zakładka1")
$hTabitem = GUICtrlCreateTabItem("zakładka2")
GUICtrlCreateTabItem("zakładka3")
GUICtrlCreateTabItem("")

$hGUI_2 = GUICreate("GUI_2", -1, -1, 100, 100) ;tworzenie GUI_2

GUISwitch($hGUI_2)                      ;bieżące okno GUI_2
GUISetState()                          ;aktywne okno GUI_2

GUISwitch($hGUI_1, $hTabitem)           ;ustawienie okna bieżącego na GUI_1
GUICtrlCreateButton("OK", 50, 50, 50) ;rysujemy przycisk w bieżącym oknie,
GUICtrlCreateTabItem("")              ;które jest niewidoczne

Do
   $msg = GUIGetMsg()
Until $msg = $GUI_EVENT_CLOSE

GUISetState()                          ;aktywne okno GUI_1
Do
   $msg = GUIGetMsg()
Until $msg = $GUI_EVENT_CLOSE


Odczyt informacji o kursorze myszki[edytuj]

GUIGetCursorInfo ( [uchwyt] )

Funkcja zwraca tablicę zawierającą informacje o kursorze lub 0 gdy wystąpi błąd (dodatkowo makro @error przyjmuje wartość 1).

Zawartość komórek tablicy:
[0] - współrzędna pozioma (x) kursora wewnątrz okna
[1] - współrzędna pionowa (y) kursora wewnątrz okna
[2] - stan pierwszego przycisku (1 wciśnięty, 0 nie wciśnięty)
[3] - stan drugiego przycisku (1 wciśnięty, 0 nie wciśnięty)
[4] - ID kontrolki nad którą znajduje się kursor (0 jeżeli nad żadną)

Położenie wg współrzędnych wewnętrznych okna.

uchwyt - parametr opcjonalny, uchwyt do okna GUI, którego dotyczy funkcja (domyślnie okno bieżące). Jeżeli zostanie podany, to okno stanie się oknem bieżącym. Jeżeli nie jest podany to okno GUI musi być aktywne.

Funkcja działa tylko na oknach utworzonych przez GUICreate.

UWAGA: Dla ListViewItem i TreeViewItem zwracane jest IDE kontrolki nadrzędnej utworzonej przez Listview lub TreeView.


Odczytanie identyfikatora (ID) zdarzenia lub uchwytu do użytej kontrolki[edytuj]

GUIGetMsg ( [opcja] )

Funkcja zwraca wartość opisującą zdarzenie jakie zaszło w GUI. Wartość ta może być liczbą lub tablicą w zależności od użytego parametru.

opcja - parametr opcjonalny określający czy zwracana wartość ma być liczbą czy tablicą

0 - zwracana jest liczba która jest identyfikatorem (ID) zdarzenia, i tak zwracana przez funkcję liczba oznacza uchwyt do użytej kontrolki lub:

0                        - nie zaszło żadne zdarzenie
$GUI_EVENT_CLOSE         - użyto przycisku zamknięcia okna 
$GUI_EVENT_MINIMIZE      - użyto przycisku minimalizacji okna
$GUI_EVENT_RESTORE       - przywrócono okno klikając na ikonę na pasku zadań
$GUI_EVENT_MAXIMIZE      - użyto przycisku maksymalizacji okna
$GUI_EVENT_MOUSEMOVE     - przesunięto kursor myszki
$GUI_EVENT_PRIMARYDOWN   - wciśnięto główny klawisz myszki (najczęściej lewy, chyba że mamy ustawienia dla leworęcznych)
$GUI_EVENT_PRIMARYUP     - zwolniono główny klawisz myszki
$GUI_EVENT_SECONDARYDOWN - wciśnięto drugi klawisz myszki (najczęściej praw, chyba że mamy ustawienia dla leworęcznych)
$GUI_EVENT_SECONDARYUP   - zwolniono drugi klawisz myszki
$GUI_EVENT_RESIZED       - zmiana wielkości okna
$GUI_EVENT_DROPPED       - zakończono operację Przeciągnij i upuść (Drag&Drop), makra @GUI_DRAGID, @GUI_DRAGFILE,
                           @GUI_DROPID zawierają informację (ID) co i gdzie zostało przeciągnięte.

1 - zwracana jest tablica zawierająca dodatkowe informacje o zdarzeniu:

komórka [0] - identyfikator zdarzenia, jak powyżej
komórka [1] - uchwyt okna, w którym zaszło zdarzenie
komórka [2] - uchwyt kontrolny (jeżeli istnieje)
komórka [3] i [4] - położenie kursora myszki w momencie zdarzenia (we współrzędnych okna)

Funkcja nie obciąża zbytnio procesora więc może być używana w pętlach.

UWAGA: Przy wartościach zwracanych przez funkcję nie podano liczb lecz nazwy stałych. Stałe te są predefiniowane nie w interpreterze lecz w specjalnym pliku (GUIConstantsEx.au3), aby można było z nich skorzystać należy plik z definicjami dołączyć do swojego skryptu za pomocą dyrektywy #include. Plik jest dostępny w dystrybucji języka w folderze "Include".

Czemu jednak nie wpisujemy bezpośrednio liczb, zamiast predefiniowanych nazw zmiennych. Są przynajmniej dwa powody takiego postępowania. Po pierwsze nazwy stałych są tak dobrane, że kojarzą się z działaniem które wywołują, są więc łatwiejsze do zapamiętania. Po drugie kod skryptu staje się bardziej czytelny gdyż łatwiej będzie go przeanalizować czytając nazwy stałych, bez konieczności pamiętania wartości, które im odpowiadają.


Odczyt stylu okna[edytuj]

GUIGetStyle ( [ uchwyt] )

Funkcja zwraca tablicę z wartościami opisującymi styl okna lub 0 gdy wystąpił błąd.

Zawartość komórek tablicy:
[0] - parametr Style
[1] - parametr exStyle

uchwyt - uchwyt okna do którego ma się odnosić ta funkcja (należy podać gdy mamy większą ilość utworzonych okien, a funkcja nie dotyczy okna bieżącego, w przeciwnym wypadku parametr można pominąć).


Definiowanie skrótów klawiszowych aktywnych w GUI[edytuj]

GUISetAccelerators ( tablica_skrótów [, uchwyt] )

Funkcja zwraca 1 gdy sukces lub 0 gdy wystąpił błąd.

tablica_skrótów - dwuwymiarowa tablica z opisem skrótów klawiszowych. Tablica w pierwszym wymiarze musi mieć tyle komórek co jest skrótów, a w drugim wymiarze 2 komórki.

[0][0] - string z opisem skrótu
[0][1] - ID kontrolki, której użycie jest symulowane przez klawisze skrótu (zwracane przez GUICtrlCreate)
  ...

uchwyt - uchwyt okna do którego ma się odnosić ta funkcja (należy podać gdy mamy większą ilość utworzonych okien, a funkcja nie dotyczy okna bieżącego, w przeciwnym wypadku parametr można pominąć).

UWAGA: - aby wyłączyć skróty należy wywołać funkcję z parametrem nie będącym tablicą np.: GUISetAccelerators(0).

Przykład:

#include <GUIConstantsEx.au3>

GUICreate("Zamknięcie okna klawiszami CTRL+ALT+END", 400, 280)
$hKoniecID = GUICtrlCreateButton("Koniec", 100, 200, 200, 20)
Dim $aTab[1][2]=[["^!{END}",$hKoniecID]]
GUISetAccelerators($aTab)                ;włączenie skrótu klawiszowego
GUISetState()
Do
   $msg = GUIGetMsg()
Until $msg=$GUI_EVENT_CLOSE Or $msg=$hKoniecID

GUISetState(@SW_HIDE)
GUISetAccelerators(0)                   ;od teraz skrót nie zadziała
Sleep(2000)
GUISetState()
Do
   $msg = GUIGetMsg()
Until $msg=$GUI_EVENT_CLOSE Or $msg=$hKoniecID

Ustawienie koloru tła okna GUI[edytuj]

GUISetBkColor ( background [, uchwyt] )

Zmienia kolor tła na opisany wartością "background".

#include <GUIConstantsEx.au3>
GUICreate("Kolorowe okno", 400, 280)
GUISetState()
Sleep(1000)
GUISetBkColor(0xff0000)
Sleep(1000)
GUISetBkColor(0x00ff00)
Sleep(1000)
GUISetBkColor(0x0000ff)
Do
Until GUIGetMsg()=$GUI_EVENT_CLOSE


Kodowanie kolorów w AutoIt[edytuj]

Przy okazji warto dowiedzieć się coś o sposobie kodowania kolorów w AutoIt. Jest on bardzo prosty jeżeli użyjemy zapisu szesnastkowego. Schemat wygląda następująco:

0xRRGGBB - jest to 6-cyfrowa liczba heksadecymalna (szesnastkowa) zbudowana z trzech dwucyfrowych bloków np.: 0x12F0B3

RR - natężenie koloru czerwonego (od 0 do FF)

GG - natężenie koloru zielonego (od 0 do FF) 

BB - natężenie koloru niebieskiego (od 0 do FF)

Informacja ta przyda się nam we wszystkich funkcjach ustalających lub odczytujących kolory.


Ustawienie współrzędnych bezwzględnych dla następnych kontrolek[edytuj]

GUISetCoord ( x, y [, szerokość [, wysokość [, uchwyt]]] )

Funkcja służy do przeniesienia początku układu współrzędnych w oknie GUI. Normalnie początek układu jest w lewym górnym narożniku okna.

Funkcja zwraca 1 gdy sukces lub 0 gdy wystąpił błąd.

x i y - przesunięcie współrzędnych początku nowego układu w poziomie i pionie

szerokość i wysokość - domyślne wymiary następnych kontrolek

uchwyt - uchwyt okna do którego ma się odnosić ta funkcja (należy podać gdy mamy większą ilość utworzonych okien, a funkcja nie dotyczy okna bieżącego, w przeciwnym wypadku parametr można pominąć).

UWAGA: Aby funkcja była aktywna należy zadeklarować Opt("GUICoordMode",2) (domyślnie jest Opt("GUICoordMode",1)).


Wygląd kursora myszki[edytuj]

GUISetCursor ( [ID_kursora [, obszar [, uchwyt]]] )

Funkcja zmienia wygląd kursora zgodnie z podanym ID_kursora (-1 kursor domyślny):

 0 = HAND        (łapka)
 1 = APPSTARTING (strzałka z animowanym niebieskim kółkiem)
 2 = ARROW       (strzałka)
 3 = CROSS       (krzyżyk)
 4 = HELP        (strzałka ze znakiem zapytania)
 5 = IBEAM       (jak wielkie I, tryb insert w edytorach)
 6 = ICON
 7 = NO          (czerwone kółko ze skośną poprzeczką)
 8 = SIZE
 9 = SIZEALL     (krzyżyk ze strzałkami na końcach)
10 = SIZENESW    (skośna linia ze strzałkami na końcach  /)
11 = SIZENS      (pionowa linia ze strzałkami na końcach |)
12 = SIZENWSE    (skośna linia ze strzałkami na końcach  \)
13 = SIZEWE      (pozioma linia ze strzałkami na końcach -)
14 = UPARROW     (strzałka z grotem do góry)
15 = WAIT        (animowane niebieskie kółko)
16 = UNKNOWN     (kursor ukryty)

obszar - określa obszar zmiany kursora (0 - obszar nie zajęty przez kontrolki (domyślnie), 1 - cały obszar okna (z wyjątkiem belki))

Przykład:

#include <GUIConstantsEx.au3>

Global $IDC = -1

;rejestrowanie funkcji wywoływanej po kliknięciu lewym klawiszem myszki
GUIRegisterMsg ( 0x202, "SetCursor" )

GUICreate("Zmiana kursora w oknie GUI", 400, 400, -1, -1, 0x04CF0000)
GUISetState()

Do
   ToolTip("ID kursora: #" & $IDC)
Until GUIGetMsg() = $GUI_EVENT_CLOSE


Func SetCursor()
   $IDC += 1
   If $IDC > 15 Then $IDC = 0
   GUISetCursor($IDC) ;zmiana kursora
EndFunc


Ustawienie bieżącej czcionki[edytuj]

GUISetFont (wielkość_fontu [, waga_fontu [, atrybut [, nazwa_fontu [, uchwyt[, jakość_fontu]]]]] )

Funkcja zwraca 1 gdy sukces lub 0 gdy wystąpił błąd.

wielkość_fontu - wielkość fontów (domyślnie 8,5; typowe rozmiary to: 6 8 9 10 11 12 14 16 18 20 22 24 26 28 36 48 72)

Pozostałe opcjonalnie:

waga_fontu - tzw. waga fontu, czyli grubość linii tworzących fonty, wartość od 0 do 1000 (domyślnie 400, mniejsze wartości to fonty pocienione, większe pogrubione)

atrybut - atrybuty fontu (2 - pochylony (italic), 4 - podkreślony, 8 - przekreślony, domyślnie 1 - font zwykły. Wartości atrybutów można sumować np. 6 (2+4) - podkreślony italic)

"nazwa_fontu" - nazwa użytych fontów, zgodna z nazwami systemowymi np.:Arial, Comic Sans MS, Courier New, Lucida Console, Microsoft Sans Serif, System, Tahoma, Times New Roman, WingDings itd. (domyślnie - domyślny font systemowy).

uchwyt - uchwyt okna do którego ma się odnosić ta funkcja (należy podać gdy mamy większą ilość utworzonych okien, a funkcja nie dotyczy okna bieżącego, w przeciwnym wypadku parametr można pominąć).

jakość_fontu - domyślnie 2 (PROOF_QUALITY)

Przykład:

#include <GUIConstantsEx.au3>

GUICreate("Test fontów w oknie GUI")

$sFont = "Comic Sans MS"
GUISetFont(16, 400, 2, $sFont)
GUICtrlCreateLabel("Pismo pochylone.", 10, 20)

GUISetFont(9, Default, 4, $sFont)
GUICtrlCreateLabel("Pismo podkreślone.", 10, 60)

GUISetFont(20, Default, 14, $sFont)
GUICtrlCreateLabel("Wszystko naraz.", 10, 90)

GUISetFont(20, 1000, 14, $sFont)
GUICtrlCreateLabel("Wszystko naraz - pogrubione.", 10, 130)

GUISetState()
Do
Until GUIGetMsg()=$GUI_EVENT_CLOSE


Ustalenie programu uruchamianego po wciśnięciu klawisza F1 (używane do wywoływania pliku pomocy)[edytuj]

GUISetHelp ( "pomoc" [, uchwyt] )

Funkcja po wciśnięciu klawisza F1 uruchamia program o podanej nazwie (najczęściej używane do wywołania pliku pomocy).

"pomoc" - nazwa pliku (może być ze ścieżką dostępu) uruchamianego po wciśnięciu klawisza F1

uchwyt - uchwyt okna do którego ma się odnosić ta funkcja (należy podać gdy mamy większą ilość utworzonych okien, a funkcja nie dotyczy okna bieżącego, w przeciwnym wypadku parametr można pominąć).


Ustalenie ikony wyświetlanej na belce okna i pasku zadań[edytuj]

GUISetIcon ( "plik_ikony" [, ID_ikony [, uchwyt]] )

Funkcja zwraca 1 gdy sukces lub 0 gdy wystąpił błąd (np. plik ikony nie istnieje).

"plik_ikony" - nazwa pliku ikony wraz ze ścieżką dostępu

ID_ikony - numer ikony w pliku ikon (jeżeli plik zawiera bibliotekę ikon), domyślnie -1

uchwyt - uchwyt okna do którego ma się odnosić ta funkcja (należy podać gdy mamy większą ilość utworzonych okien, a funkcja nie dotyczy okna bieżącego, w przeciwnym wypadku parametr można pominąć).


Ustalenie (rejestrowanie) jaka funkcja użytkownika ma być wywołana, jeżeli zostanie wciśnięty jakiś przycisk systemowy okna[edytuj]

GUISetOnEvent ( specialID, "nazwa_funkcji" [, uchwyt] )

Funkcja zwraca 1 gdy sukces lub 0 gdy wystąpił błąd.

specialID - ID zdarzenia (jak dla GUIGetMsg)

"nazwa_funkcji" - nazwa rejestrowanej funkcji, string pusty "" oznacza wyrejestrowanie danej funkcji

uchwyt - uchwyt okna do którego ma się odnosić ta funkcja (należy podać gdy mamy większą ilość utworzonych okien, a funkcja nie dotyczy okna bieżącego, w przeciwnym wypadku parametr można pominąć).

UWAGA: Aby funkcja była aktywna należy zadeklarować Opt("GUIOnEventMode",1) (domyślnie jest Opt("GUIOnEventMode",0)), powoduje to jednocześnie wyłączenie funkcji GUIGetMsg.

Zadeklarowanie Opt("GUIOnEventMode",0) przywraca stan pierwotny.

Przykład:

#include <GUIConstantsEx.au3>
Opt("GUIOnEventMode",1)
Global $my_GUI_EVENT_CLOSE=False

GUICreate("Przechwycenie zdarzenia", 400, 280)
GUISetOnEvent($GUI_EVENT_CLOSE,"my") ;rejestrowanie funkcji
GUISetState()

Do
Until $my_GUI_EVENT_CLOSE

Sleep(1500)
GUISetState()

Opt("GUIOnEventMode",0) ;przywrócenie stanu pierwotnego
Do
Until GUIGetMsg()=$GUI_EVENT_CLOSE

;własna funkcja obsługi przycisku zamknięcia okna
Func my()
   Beep(500,1000)
   MsgBox(0,"","Przechwycenie!")
   $my_GUI_EVENT_CLOSE=True
   GUISetState(@SW_HIDE)
EndFunc


Ustawienie statusu okna (widoczne, niewidoczne, zminimalizowane itp.)[edytuj]

GUISetState ( [flaga [, uchwyt]] )

Funkcja zwraca 1 gdy sukces, lub 0 gdy wystąpił błąd.

Parametry (oba opcjonalne):

flaga - określa sposób wyświetlania okna, podaje się jako makro

@SW_SHOW - pokazuje wcześniej ukryte okno (domyślne)

@SW_HIDE - okno ukryte

@SW_MINIMIZE - okno zminimalizowane

@SW_MAXIMIZE - okno zmaksymalizowane

@SW_RESTORE - cofnięcie minimalizacji okna

@SW_DISABLE - okno unieruchomione

@SW_ENABLE - odblokowanie okna

@SW_LOCK - okno zablokowane (nie można w nim nic narysować)

@SW_UNLOCK - okno odblokowane

uchwyt - uchwyt okna do którego ma się odnosić ta funkcja (należy podać gdy mamy większą ilość utworzonych okien, a funkcja nie dotyczy okna bieżącego, w przeciwnym wypadku parametr można pominąć).


Ustawienie stylu okna[edytuj]

GUISetStyle ( Style [,ExStyle [, uchwyt]] )

Funkcja zwraca 1 gdy sukces lub 0 gdy wystąpił błąd.

style i exstyle to parametry określające wygląd tworzonego okna, nie będziemy ich tutaj szczegółowo omawiać. Aby uzyskać wartości domyślne należy wpisać -1 lub Default.

uchwyt - uchwyt okna do którego ma się odnosić ta funkcja (należy podać gdy mamy większą ilość utworzonych okien, a funkcja nie dotyczy okna bieżącego, w przeciwnym wypadku parametr można pominąć).

Przykład (kilka efektów zmiany wyglądu okna):

#include <GUIConstantsEx.au3>
#include <WindowsConstants.au3>

GUICreate("Gui Style", 250, 150)
$hl=GUICtrlCreateLabel("Okno typowe",50,50,150,20)
GUISetState()
Sleep(2000)
GUISetStyle($WS_BORDER)
GUICtrlSetData($hl,"Tylko pojedyncza ramka")
Sleep(2000)
GUISetStyle($WS_CAPTION)
GUICtrlSetData($hl,"Bez przycisków systemowych")
Sleep(2000)
GUISetStyle($WS_POPUP)
GUICtrlSetData($hl,"Bez ramki")
Sleep(2000)
GUISetStyle($WS_SIZEBOX)
GUICtrlSetData($hl,"Bez belki")
Sleep(2000)
GUISetStyle($WS_DLGFRAME)
GUICtrlSetData($hl,"Ramka cień")
Sleep(2000)

Opis funkcji kontrolek GUI[edytuj]

Usunięcie kontrolki[edytuj]

GUICtrlDelete ( ID_kontrolki )

Funkcja zwraca 1 gdy sukces lub 0 gdy wystąpił błąd.

ID_kontrolki - identyfikator kontrolki zwracany przez funkcję ją tworzącą.

Przykład:

#include <GUIConstantsEx.au3>
GUICreate("Test usuwania kontrolek", 300, 200)              ;tworzenie okna GUI
$hDel = GUICtrlCreateButton("Usuwanie kontrolki",95,50,110,20) ;tworzenie kontrolki
GUISetState()                                               ;wywołanie GUI
Do
   $msg = GUIGetMsg()                      ;odczyt zdarzenia w GUI
   If $msg = $hDel Then GUICtrlDelete($hDel) ;jeżeli użyto kontrolki to jej usunięcie
Until $msg = $GUI_EVENT_CLOSE


Odczyt danych z kontrolki lub jej statusu[edytuj]

GUICtrlRead ( ID_kontrolki [, opcje] )

Zwracane dane zależą od rodzaju kontrolki i wartości opcjonalnego parametru opcje.

Jeżeli wystąpił błąd zwracane jest 0.

ID_kontrolki - identyfikator kontrolki zwracany przez funkcję ją tworzącą.

opcje - opcjonalny parametr określający rodzaj zwracanej informacji, 0 - funkcja zwraca dane z kontrolki lub jej status (domyślnie), 1 - zwracane są dodatkowe informacje o użytej kontrolce.

Zwracane wartości w zależności od rodzaju kontrolki (dla opcje=0):

CHECKBOX, RADIO - status kontrolki (patrz tabelę statusów w GUICtrlSetState)
COMBO, LIST     - wybrana wartość 
INPUT, EDIT     - tekst wewnątrz kontrolki
BUTTON          - tekst na przycisku
DATE            - wybrana data
PROGRESS        - aktualny postęp w procentach
SLIDER          - aktualna wartość
TAB             - numer wybranej zakładki
MENU, MENU_ITEM - status kontrolki (patrz tabelę statusów w GUICtrlSetState)
TREE_VIEW       - ID wybranej pozycji (zwracane przez TreeViewItem)
TREE_VIEW_ITEM  - status kontrolki
LIST            - nazwa wybranej pozycji lub pusty string gdy nie wybrano żadnej pozycji
LIST_VIEW       - ID wybranej pozycji (zwracane przez ListViewItem), 0 gdy żadna pozycja nie została wybrana
LIST_VIEW_ITEM  - tekst wewnątrz kontrolki
DUMMY           - wartość ustawiona przez GUICtrlSendToDummy lub GUICtrlSetData

Zwracane wartości w zależności od rodzaju kontrolki (dla opcje=1):
(nie wszystkie kontrolki mają rozszerzone dane, tylko wymienione poniżej)
CHECKBOX, RADIO - tekst na kontrolce
MENU, MENU_ITEM - tekst na kontrolce
TREE_VIEW       - tekst na wybranej kontrolce TREE_VIEW_ITEM
TREE_VIEW_ITEM  - tekst na kontrolce
LIST_VIEW_ITEM  - status kontrolki (patrz tabelę statusów w GUICtrlSetState)
TAB             - ID wybranej zakładki

Przykład:

#include <GUIConstantsEx.au3>
GUICreate("Test GUICtrlRead:", 350, 250,400)
$hID1 = GUICtrlCreateButton("Przycisk",10,20)
$hID2 = GUICtrlCreateCheckbox("Zaznacz", 100, 20, 80, 20)
$hID3 = GUICtrlCreateSlider(10, 50, 120, 30)
$hID4 = GUICtrlCreateInput("Okienko wprowadzania", 200, 55, 130, 20)

$hID5 = GUICtrlCreateList("", 30, 120, 100, 90)
GUICtrlSetData(-1, "1. To|2. Jest|3. Lista|4. Wyboru", "2. Jest")

$hMenu = GUICtrlCreateMenu("Menu 1")
$hID6 = GUICtrlCreateMenuItem("Opcja 1", $hMenu)

$hID7=GUICtrlCreateDate("",180, 150, 150, 20)

GUISetState()

Do
   $msg=GUIGetMsg()
   Switch $msg
      Case $hID1,$hID2,$hID3,$hID4,$hID5,$hID6,$hID7
         MsgBox(0,"opcje=0:",GUICtrlRead($msg),1.5)
	 Sleep(250)
	 MsgBox(0,"opcje=1:",GUICtrlRead($msg,1),1.5)
EndSwitch
Until $msg=$GUI_EVENT_CLOSE


Przesłanie komunikatu do kontrolki[edytuj]

GUICtrlSendMsg ( ID_kontrolki, msg, wPar, lPar )

Funkcja przesyła komunikat do kontrolki i zwraca wartość zwracaną przez SendMessage Windows API lub 0 gdy wystąpił błąd.

ID_kontrolki - identyfikator kontrolki zwracany przez funkcję GUICtrlCreate...

msg - liczba będąca komunikatem wysyłany do kontrolki.

wPar i lPar - parametry przekazywane wraz z komunikatem (jeżeli parametr nie występuje w danym komunikacie to przypisujemu mu wartość 0). Domyślną wartość parametru (jeżeli taka występuje) otrzymujemy podając -1 lub Default.


UWAGA:

Aby móc korzystać z funkcji GUICtrlSendMsg musimy znać jakie komunikaty i jakie parametry można wysłać do danej kontrolki, a także jakich odpowiedzi możemy oczekiwać. W zasadzie należało by zapoznać się z dokumentacją SendMessage Windows API.

Niektóre komunikaty, które można przesłać do kontrolek są zawarte w plikach deklaracji stałych kontrolek (np.: EditConstants.au3).

W poniższy przykładzie zademonstrowano niektóre komunikaty przesyłane do kontrolki EDIT.

$EM_LINEFROMCHAR (0xC9) - zwraca nr wiersza, w którym znajduje się znak o numerze podanym w parametrze wPar, dla wartości domyślnej będzie to nr wiersza z kursorem (należy pamiętać, że wiersze są numerowane od 0).

$EM_LINEINDEX (0xBB) - zwraca nr pierwszego znaku w wierszu o numerze podanym w parametrze wPar, dla wartości domyślnej będzie to nr pierwszego znaku w wierszu z kursorem.

$EM_LINELENGTH (0xC1) - zwraca długość wiersza o numerze podanym w parametrze wPar, dla wartości domyślnej będzie to długość wiersza z kursorem.

$EM_GETLINECOUNT (0xBA) - zwraca ilość wszystkich wierszy w kontrolce (nie przyjmuje żadnego parametru).

#include <GUIConstantsEx.au3>
#include <EditConstants.au3>

GUICreate("Test: GUICtrlSendMsg")

$hIDEdit = GUICtrlCreateEdit("", 10, 10,380,300)
GUICtrlCreateButton("Odczyt", 180, 350, 50)
GUISetState()

For $n = 0 To 15
   GUICtrlSetData($hIDEdit,"wiersz " & $n & @CRLF, 1)
Next
GUICtrlSetData($hIDEdit,"wiersz 16", 1)

Do
   $msg = GUIGetMsg()
   If $msg > 0 Then
      $iNline = GUICtrlSendMsg($hIDEdit, $EM_LINEFROMCHAR, Default, 0)
      $iNfchr = GUICtrlSendMsg($hIDEdit, $EM_LINEINDEX, Default, 0)
      $iLline = GUICtrlSendMsg($hIDEdit, $EM_LINELENGTH , Default, 0)
      $iCline = GUICtrlSendMsg($hIDEdit, $EM_GETLINECOUNT , 0, 0)
      GUICtrlSetState($hIDEdit, $GUI_FOCUS)
      MsgBox(0,"GUICtrlSendMsg", "Nr wiersza z kursorem: " & $iNline & @CRLF & _
               "Nr pierwszego znaku w wierszu z kursorem: " & $iNfchr & @CRLF & _
	       "Długość wiersza: " & $iLline & @CRLF & _
	       "Ilość wszystkich wierszy: " & $iCline)
   EndIf
Until $msg = $GUI_EVENT_CLOSE


GUICtrlRecvMsg ( ID_kontrolki , msg [, wPar [, ParTyp]] )

Funkcja przesyła komunikat do kontrolki i zwraca wartość zwracaną przez SendMessage Windows API lub 0 gdy wystąpił błąd.

ID_kontrolki - identyfikator kontrolki zwracany przez funkcję GUICtrlCreate...

msg - liczba będąca komunikatem wysyłany do kontrolki.

Pozostałe opcjonalne:

wPar - parametr typu INTEGER przekazywany wraz z komunikatem . Domyślną wartość parametru (jeżeli taka występuje) otrzymujemy podając -1 lub Default.

ParTyp - typ zwracanej wartości, 0 (domyślnie) - tablica 2-elementowa, 1 - string, 2 - struktura RECT.

Struktura RECT jest zwracany jako tablica 4-elementowa (Left, Top, Right, Bottom).

Działanie funkcji jest bardzo podobne do GUICtrlSendMsg. Jedyną różnicą jest możliwość uzyskania odpowiedzi innych typów niż INTEGER.

Przykład z użyciem komunikatu:

$EM_GETSEL - zwraca numer pierwszego i ostatniego znaku w zaznaczonym fragmencie tekstu (w postaci tablicy 2-elementowej), nie przyjmuje parametru.

#include <GUIConstantsEx.au3>
#include <EditConstants.au3>

GUICreate("Test: GUICtrlRecvMsg")

$hIDEdit = GUICtrlCreateEdit("", 10, 10,380,300)
GUICtrlCreateButton("Odczyt", 180, 350, 50)
GUISetState()

For $n = 0 To 15
   GUICtrlSetData($hIDEdit,"wiersz " & $n & @CRLF, 1)
Next
GUICtrlSetData($hIDEdit,"wiersz 16", 1)

Do
   $msg = GUIGetMsg()
   If $msg > 0 Then
      $a = GUICtrlRecvMsg($hIDEdit, $EM_GETSEL)
      GUICtrlSetState($hIDEdit, $GUI_FOCUS)
      MsgBox(0, "Zaznaczenie:", StringFormat("początek=%d  koniec=%d", $a[0], $a[1]),2)
   EndIf
Until $msg = $GUI_EVENT_CLOSE


Symulacja użycia atrapy kontrolki[edytuj]

GUICtrlSendToDummy ( ID_kontrolki [, status] )

Funkcja zwraca 1 gdy sukces lub 0 gdy wystąpił błąd.

ID_kontrolki - identyfikator kontrolki zwracany przez funkcję GUICtrlCreateDummy

status - opcjonalny parametr określający wartość zwracaną po wywołaniu funkcji GUICtrlRead

Wywołanie tej funkcji działa tak jak użycie prawdziwej kontrolki.

Przykład:

#include <WindowsConstants.au3>
GUICreate("                       Masz 5 sekund!", 250, 200,500)
GUISetStyle($WS_CAPTION)                         ;okno bez przycisków systemowych
$hB1 = GUICtrlCreateButton("Przycisk 1", 20, 40, 100, 30)
$hB2 = GUICtrlCreateButton("Przycisk 2", 20, 120, 100, 30)
$hAt = GUICtrlCreateDummy()                                   ;tworzenie atrapy

GUISetState()
$begin = TimerInit()                                       ;inicjalizacja timera
Do
   $m = GUIGetMsg()
   If $m = $hB1 or $m = $hB2 Then ExitLoop
   If TimerDiff($begin)>5000 Then                          ;odczyt timera
      GUICtrlSendToDummy($hAt,"Za długo się zastanawiasz!") ;symulacja użycia atrapy
	 $m = $hAt
	 ExitLoop
   endif
Until 0

MsgBox(0,"Wybrałes:",GUICtrlRead($m),5)


Animacja (AVI)[edytuj]

GUICtrlCreateAvi ( "nazwa_pliku", ID_animacji, x, y [, szerokość [, wysokość [, style [, exStyle]]]] )

Funkcja zwraca ID tworzonej kontrolki lub 0 gdy wystąpił błąd.

"nazwa_pliku" - nazwa pliku z animacją (może być łącznie ze ścieżką dostępu).

ID_animacji - numer animacji w pliku animacji (jeżeli plik zawiera bibliotekę animacji), domyślnie -1 lub Default.

x i y - położenie wewnątrz okna GUI (w pikselach).

Pozostałe parametry opcjonalne:

szerokość i wysokość - wielkość pola animacji (w pikselach).

style i exstyle - parametry określające styl kontrolki

Przykład:

#include <GUIConstantsEx.au3>
GUICreate("Test kontrolki animacji AVI", 350, 200)
$hAni = GUICtrlCreateAvi(@SystemDir & "\shell32.dll", 165, 50, 10)
$hStart = GUICtrlCreateButton("START", 100, 150, 70, 22)
$hStop = GUICtrlCreateButton("STOP", 200, 150, 70, 22)
GUISetState()
Do
   $msg = GUIGetMsg()
   If $msg = $hStop Then GUICtrlSetState($hAni, 0)
   If $msg = $hStart Then GUICtrlSetState($hAni, 1)
Until $msg = $GUI_EVENT_CLOSE


Przycisk (BUTTON)[edytuj]

GUICtrlCreateButton ( "tekst", x, y [, szerokość [, wysokość [, style [, exStyle]]]] )

Funkcja zwraca ID tworzonej kontrolki lub 0 gdy wystąpił błąd.

"tekst" - tekst na przycisku.

x i y - położenie wewnątrz okna GUI (w pikselach).

Pozostałe parametry opcjonalne:

szerokość i wysokość - wielkość pola animacji (w pikselach).

style i exstyle - parametry określające styl kontrolki

Nazwa stałej     | Hex      | Opis
<ButtonConstants.au3>       |
--------------------------------------------------------------------------------------
style
--------------------------------------------------------------------------------------
$BS_DEFPUSHBUTTON|      0x1 | przycisk domyślny, zadziała po wciśnięciu klawisza ENTER
$BS_ICON         |     0x40 | można wstawić ikonę zamiast tekstu
$BS_BITMAP       |     0x80 | można wstawić bitmapę (BMP) zamiast tekstu
$BS_CENTER       |    0x300 | centrowanie tekstu w poziomie
$BS_TOP          |    0x400 | tekst na górze przycisku
$BS_BOTTOM       |    0x800 | tekst na dole przycisku
$BS_VCENTER      |    0xC00 | centrowanie tekstu w pionie
$BS_MULTILINE    |   0x2000 | dopuszczalny tekst wielowierszowy
--------------------------------------------------------------------------------------
exstyle          |      0x1 | przycisk z ramką
--------------------------------------------------------------------------------------

Przykład (kilka efektów za pomocą parametru style i exstyle):

#include <GUIConstantsEx.au3>
GUICreate("GUI z przyciskami")
$hButton_1 = GUICtrlCreateButton("Przycisk 1", 100, 30, 100)
$hButton_2 = GUICtrlCreateButton("Przycisk 2"&@LF&"wielo-"&@LF&"wierszowy", 210,30,100,Default,0x2000)
$hButton_3 = GUICtrlCreateButton("", 10, 120, 140, 50, 0x40)
GUICtrlSetImage(-1, "shell32.dll", 28)
$hButton_4 = GUICtrlCreateButton("Przycisk 4", 10, 190, 140, 50, 0x1)
$hButton_5 = GUICtrlCreateButton("Przycisk 5", 10, 260, 140, 50, Default,0x5)

GUISetState()
Do
   $msg = GUIGetMsg()
   If $msg = $hButton_1 Then MsgBox(0, "Test",'Wcisnąłeś "Przycisk 1"')
   If $msg = $hButton_2 Then MsgBox(0, "Test",'Wcisnąłeś "Przycisk 2"')
   If $msg = $hButton_3 Then MsgBox(0, "Test",'Wcisnąłeś "Przycisk z ikoną"')
   If $msg = $hButton_4 Then MsgBox(0, "Test",'Wcisnąłeś "Przycisk 4" (domyślny)')
   If $msg = $hButton_5 Then MsgBox(0, "Test",'Wcisnąłeś "Przycisk 5" z ramką')
Until $msg = $GUI_EVENT_CLOSE


Pola wyboru (CHECKBOX)[edytuj]

GUICtrlCreateCheckbox ( "tekst", x, y [, szerokość [, wysokość [, style [, exStyle]]]] )

Funkcja zwraca ID tworzonej kontrolki lub 0 gdy wystąpił błąd.

"tekst" - tekst obok pola.

x i y - położenie wewnątrz okna GUI (w pikselach).

Pozostałe parametry opcjonalne:

szerokość i wysokość - wielkość pola kontrolki (w pikselach).

style i exstyle - parametry określające styl kontrolki.

UWAGA: Kontrolka ma dwa stany - zaznaczona lub niezaznaczona. Odczyt stanu kontrolki przy użyci funkcji GUICtrlRead lub GUICtrlGetState, ustawianie kontrolki funkcją GUICtrlSetState.

Przykład:

#include <GUIConstantsEx.au3>
Local $col=0xffffff, $col1=0
GUICreate("Test CHECKBOX - usuwanie składowych kolorów")
$check1 = GUICtrlCreateCheckbox("Usuń czerwony", 10, 10, 120, 20)
$check2 = GUICtrlCreateCheckbox("Usuń zielony", 150, 10, 120, 20)
$check3 = GUICtrlCreateCheckbox("Usuń niebieski", 300, 10, 120, 20)
GUISetState()

Do
   $msg = GUIGetMsg()
   ;odczyt stanów poszczególnych pól
   $R=(GUICtrlRead($check1)=$GUI_UNCHECKED)*0xff
   $G=(GUICtrlRead($check2)=$GUI_UNCHECKED)*0xff
   $B=(GUICtrlRead($check3)=$GUI_UNCHECKED)*0xff
   $col=$R*0x10000+$G*0x100+$B              ;wyliczenie kodu koloru
   If $col<>$col1 Then GUISetBkColor($col)  ;ustawienie koloru tła
   $col1=$col
Until $msg = $GUI_EVENT_CLOSE


Lista rozwijana (COMBO)[edytuj]

GUICtrlCreateCombo ( "tekst", x, y [, szerokość [, wysokość [, style [, exStyle]]]] )

Funkcja zwraca ID tworzonej kontrolki lub 0 gdy wystąpił błąd.

"tekst" - tekst obok pola.

x i y - położenie wewnątrz okna GUI (w pikselach).

Pozostałe parametry opcjonalne:

szerokość i wysokość - wielkość pola kontrolki (w pikselach).

style i exstyle - parametry określające styl kontrolki.

Nazwa stałej         | Hex      | Opis
<ComboConstants.au3> |          |
--------------------------------------------------------------------------------------
style
--------------------------------------------------------------------------------------
Default  (lub -1)    |          | Styl domyślny.
                     |          | Kombinacja stylów $CBS_DROPDOWN i $CBS_AUTOHSCROL).
--------------------------------------------------------------------------------------
$CBS_AUTOHSCROLL     |    0x0040| Automatyczne przewijanie w lewo tekstu w polu edycji
                     |          | gdy tekst jest dłuższy niż to pole. Gdy styl ten nie
                     |          | jest ustawiony, nie można wprowadzić tekstu 
                     |          | dłuższego niż pole edycji.
--------------------------------------------------------------------------------------
$CBS_DISABLENOSCROLL |    0x0800| Bez pionowego paska przewijania listy.
--------------------------------------------------------------------------------------
$CBS_DROPDOWN        |    0x0002| Wyświetla tylko pole edycji, rozwinięcie listy
                     |          | poprzez naciśnięcie ikony obok pola edycji
--------------------------------------------------------------------------------------
$CBS_DROPDOWNLIST    |    0x0003| Pole tekstowe statyczne, wyświetla tylko pozycje
                     |          | z listy, nie można ręcznie wpisać tekstu.
--------------------------------------------------------------------------------------
$CBS_LOWERCASE       |    0x4000| Zamiana w polu edycji dużych liter na małe.
--------------------------------------------------------------------------------------
$CBS_SIMPLE          |    0x0001| Pole listy cały czas widoczne.
--------------------------------------------------------------------------------------
$CBS_SORT            |    0x0100| Sortowanie pól listy.
--------------------------------------------------------------------------------------
$CBS_UPPERCASE       |    0x2000| Zamiana w polu edycji małych liter na duże.
--------------------------------------------------------------------------------------
exStyle
--------------------------------------------------------------------------------------
$WS_EX_DLGMODALFRAME |0x00000001| Okno kontrolki "wklęsłe". Ustawienie domyślne.
Default lub -1       |          |
--------------------------------------------------------------------------------------
$WS_EX_LAYOUTRTL     |  0x400000| Układ odwrócony. Zamiana strony lewej z prawą.
--------------------------------------------------------------------------------------
$WS_EX_STATICEDGE    |0x00020000| Styl 3-wymiarowy obramowania kontrolki.
--------------------------------------------------------------------------------------

UWAGA: Funkcja tworzy tylko pierwszą pozycję listy, pozostałe pozycje tworzymy przy użyciu funkcji GUICtrlSetData. Odczyt tekstu z wybranej pozycji listy przy użyci funkcji GUICtrlRead, ustawianie kontrolki funkcją GUICtrlSetData.

Przykład:

#include <GUIConstants.au3>

Local $col=0xffffff, $col1=0

GUICreate("Kolor tła")
$hCombo=GUICtrlCreateCombo("Biały", 20, 20, -1, -1, $CBS_DROPDOWNLIST)  ; pierwsza pozycja listy
GUICtrlSetData(-1, "Czerwony|Zielony|Niebieski", "Biały") ;pozostałe pozycje oraz ustalenie pozycji domyślnej

GUISetState()
 
Do
   $msg = GUIGetMsg()
   Switch GUICtrlRead($hCombo)
      Case "Biały"
         $col = 0xffffff
      Case "Czerwony"
         $col = 0xff0000
      Case "Zielony"
         $col = 0x00ff00
      Case "Niebieski"
         $col = 0x0000ff
   EndSwitch
   If $col<>$col1 Then GUISetBkColor($col)  ;ustawienie koloru tła
   $col1 = $col
Until $msg = $GUI_EVENT_CLOSE

Menu kontekstowe (CONTEXT_MENU)[edytuj]

GUICtrlCreateContextMenu ( [ID] )

Fnkcja tworzy menu kontekstowe powiązane z obiektem wskazywanym przez kursor myszki. Wywołanie menu prawym klawiszem myszki. Zwraca ID tworzonej kontrolki lub 0 gdy wystąpił błąd.

ID - ID obiektu (kontrolki lub okna głównego), do którego odnosi się menu kontekstowe. Domyślnie obiekt bieżący.

Pozycje menu i podmenu tworzymy funkcją:

GUICtrlCreateMenu - jeżeli dana pozycja ma zawierać podmenu.

GUICtrlCreateMenuItem - jeżeli dana pozycja nie zawiera podmenu.

Przykład:

#include <GUIConstantsEx.au3>

$hGUI = GUICreate("Menu kontekstowe:", 300, 300)

;menu kontekstowe okna
$hContextmenu = GUICtrlCreateContextMenu()                 ;utworzenie menu kontekstowego
$hItem1 = GUICtrlCreateMenuItem("Zamknięcie okna",$hContextmenu)     ;nie zawiera podmenu
GUICtrlCreateMenuItem("", $hContextmenu) 	                     ;separator
$hItem2 = GUICtrlCreateMenu("Kolor okna", $hContextmenu)             ;zawiera podmenu
$hItem21 = GUICtrlCreateMenuItem("Zielone", $hItem2)                 ;podmenu
$hItem22 = GUICtrlCreateMenuItem("Niebieskie", $hItem2)              ;podmenu

;menu kontekstowe kontrolki
$hLab=GUICtrlCreateLabel("Przykładowy tekst" & @LF & "na etykietce", 50, 100, 200, 100, 0x1001)
GUICtrlSetFont($hLab, 16, Default, Default, "Comic Sans MS")
$hLabcontext = GUICtrlCreateContextMenu($hLab)
$hLabitem1 = GUICtrlCreateMenu("Kolor tła", $hLabcontext)
$hLabitem11 = GUICtrlCreateMenuItem("Białe", $hLabitem1)
$hLabitem12 = GUICtrlCreateMenuItem("Żółte", $hLabitem1)
$hLabitem2 = GUICtrlCreateMenu("Kolor czcionki", $hLabcontext)
$hLabitem21 = GUICtrlCreateMenuItem("Czarna", $hLabitem2)
$hLabitem22 = GUICtrlCreateMenuItem("Czerwona", $hLabitem2)

GUISetState()

Do
$msg=GUIGetMsg()
   If $msg = $hItem1 Then ExitLoop
   If $msg = $hItem21 Then GUISetBkColor(0x00ff00, $hGUI)
   If $msg = $hItem22 Then GUISetBkColor(0x0000ff, $hGUI)
   If $msg = $hLabitem11 Then GUICtrlSetBkColor($hLab, 0xffffff)
   If $msg = $hLabitem12 Then GUICtrlSetBkColor($hLab, 0xffff00)
   If $msg = $hLabitem21 Then GUICtrlSetColor($hLab, -1)
   If $msg = $hLabitem22 Then GUICtrlSetColor($hLab, 0xff0000)
Until $msg = $GUI_EVENT_CLOSE

Kalendarz (DATE)[edytuj]

GUICtrlCreateDate ( "data", x, y [, szerokość [, wysokość [, style [, exStyle]]]] )

Funkcja zwraca ID tworzonej kontrolki lub 0 gdy wystąpił błąd.

"data" - string daty w formacie rrrr/mm/dd, string pusty oznacza aktualną datę (wg zegara systemowego).

x i y - położenie wewnątrz okna GUI (w pikselach).

Pozostałe parametry opcjonalne:

szerokość i wysokość - wielkość pola kontrolki (w pikselach).

style i exstyle - parametry określające styl kontrolki.

UWAGA: Odczyt wybranej daty przy użyciu funkcji GUICtrlRead, ustawianie daty funkcją GUICtrlSetData.

Przykład (kilka efektów uzyskanych za pomocą parametru style):

#include <GUIConstantsEx.au3>

GUICreate("Kalendarz", 250, 150, 800, 250)
$date1 = GUICtrlCreateDate("1952/12/22", 10, 10, 185, 20)
$date2 = GUICtrlCreateDate("", 10, 40, 185, 20,0x1)
$date3 = GUICtrlCreateDate("", 10, 70, 185, 20,0x2)
$date4 = GUICtrlCreateDate("", 10, 100, 185, 20,0x10)
GUISetState()
Do
   $msg = GUIGetMsg()
Until $msg = $GUI_EVENT_CLOSE
MsgBox(0, "Data 1:", GUICtrlRead($date1))


Atrapa kontrolki (DUMMY)[edytuj]

GUICtrlCreateDummy ( )

Funkcja zwraca ID tworzonej kontrolki lub 0 gdy wystąpił błąd.

Funkcja tworzy kontrolkę (atrapę), która nie ma graficznej reprezentacji. Użycie tej kontrolki można symulować wywołując funkcję GUICtrlSendToDummy. Do atrapy można zapisywać dane i je odczytywać tak jak do prawdziwej kontrolki. Umożliwia to korzystanie z funkcji kontrolek bez rysowania jakiegoś obiektu graficznego na ekranie.

Przykład (Zamknięcie okna klawiszami CTRL+ALT+END):

#include <GUIConstantsEx.au3>

GUICreate("Zamknięcie okna klawiszami CTRL+ALT+END", 400, 280)
$koniecID = GUICtrlCreateDummy()
Dim $tab[1][2]=[["^!{END}",$koniecID]]
GUISetAccelerators($tab)                ;włączenie skrótu klawiszowego
GUISetState()
Do
   $msg = GUIGetMsg()
Until $msg=$GUI_EVENT_CLOSE Or $msg=$koniecID


Edytor tekstu (EDIT)[edytuj]

GUICtrlCreateEdit ( "tekst", x, y [, szerokość [, wysokość [, style [, exStyle]]]] )

Funkcja tworzy kontrolkę w postaci okienka edycyjnego, w którym można wpisywać i edytować tekst wielowierszowy.

Zwraca ID tworzonej kontrolki lub 0 gdy wystąpił błąd.

"tekst" - początkowy tekst w okienku, może być wielowierszowy.

x i y - położenie wewnątrz okna GUI (w pikselach).

Pozostałe parametry opcjonalne:

szerokość i wysokość - wielkość pola kontrolki (w pikselach).

style i exstyle - parametry określające styl kontrolki.

UWAGA: Odczyt tekstu z okienka przy użyci funkcji GUICtrlRead, zmiana tekstu funkcją GUICtrlSetData.

Kilka użytecznych wartości parametru style, nazwy stałych wg <EditConstants.au3> i <WindowsConstants.au3>:

Nazwa stałej    | Wartość hex | Opis
-----------------------------------------------------------------------------------------------
$ES_CENTER      |         0x1 | Centrowanie tekstu
$ES_RIGHT       |         0x2 | Wyrównanie do prawej
$ES_UPPERCASE   |         0x8 | Zamiana wszystkich liter na wielkie
$ES_LOWERCASE   |        0x10 | Zamiana wszystkich liter na małe
$ES_PASSWORD    |        0x20 | Maskowanie wprowadzanych znaków (*)
$ES_AUTOVSCROLL |        0x40 | Scroll ekranu w pionie, wiersz łamany
$ES_AUTOHSCROLL |        0x80 | Scroll w poziomie, ilość wierszy ograniczona wielkością okienka
$ES_READONLY    |       0x800 | Tylko do odczytu (nie można edytować)
$ES_WANTRETURN  |      0x1000 | Aktywny Enter
$ES_NUMBER      |      0x2000 | Można wprowadzać tylko cyfry
$WS_HSCROLL     |    0x100000 | Suwak okna poziomy
$WS_VSCROLL     |    0x200000 | Suwak okna pionowy

Wartości parametru można sumować np. wartość domyślna wynosi: 0x40+0x80+0x1000+0x100000+0x200000=0x3010c0

Przykład:

#include <GUIConstantsEx.au3>
Const $df=0x3010c0
GUICreate("Edytor", 250, 250, 800, 250)
$edit=GUICtrlCreateEdit("",10,10,-1,-1,$df+2)
GUISetState()
Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE
MsgBox(0, "Tekst:", GUICtrlRead($edit))


Okno grafiki (GRAPHIC)[edytuj]

GUICtrlCreateGraphic (  x, y [, szerokość [, wysokość [, style ]]] )

Funkcja tworzy kontrolkę w postaci okienka, wewnątrz którego można rysować różne obiekty geometryczne.

Zwraca ID tworzonej kontrolki lub 0 gdy wystąpił błąd.

x i y - położenie wewnątrz okna GUI (w pikselach).

Pozostałe parametry opcjonalne:

szerokość i wysokość - wielkość pola kontrolki (w pikselach).

style - parametr określający styl kontrolki.

Rysowanie przy użyciu funkcji GUICtrlSetGraphic.

Kolor tła i obramowania można ustawić za pomocą GUICtrlSetBkColor i GUICtrlSetColor.

Przykład:

#include <GUIConstantsEx.au3>
GUICreate("Okno główne", 400, 600, 400, 300)
$gr=GUICtrlCreateGraphic(10,10,380,550) ;tworzenie okienka graficznego
GUICtrlSetBkColor($gr,0xffff00)         ;kolor tła okienka
GUICtrlSetColor($gr,0)                  ;kolor obramowania
GUISetState()
Do
Until GUIGetMsg()=$GUI_EVENT_CLOSE


Grupa kontrolek (GROUP)[edytuj]

GUICtrlCreateGroup ( "tekst", x, y [, szerokość [, wysokość [, style [, exStyle]]]] )

Funkcja tworzy grupę kontrolek i rysuje ramkę wokół niej.

Zwraca ID tworzonej kontrolki lub 0 gdy wystąpił błąd.

"tekst" - tekst w górnej części ramki.

x i y - położenie ramki wewnątrz okna GUI (w pikselach).

Pozostałe parametry opcjonalne:

szerokość i wysokość - wielkość ramki (w pikselach).

style i exstyle - parametry określające styl kontrolki.

Funkcja służy do grupowania przycisków RADIO. Tylko jeden przycisk w grupie może być włączony. W przypadku innych kontrolek działanie funkcji ogranicza się do narysowania ramki.

Jeśli chcemy utworzyć grupy bez widocznych ramek powinniśmy użyć funkcji GUIStartGroup.

Przykład:

#include <GUIConstantsEx.au3>
GUICreate("Tworzenie grupy kontrolek:")
GUICtrlCreateGroup("Grupa 1:", 190, 60, 90, 80)            ;początek grupy 1
$radio_1 = GUICtrlCreateRadio("Radio 1", 210, 90, 60, 20)
$radio_2 = GUICtrlCreateRadio("Radio 2", 210, 110, 60, 20)

GUICtrlCreateGroup("Grupa 2:", 190, 160, 90, 80, 0x40000)  ;początek grupy 2
$radio_3 = GUICtrlCreateRadio("Radio 3", 210, 180, 60, 20)
$radio_4 = GUICtrlCreateRadio("Radio 3", 210, 210, 60, 20)

GUISetState()
Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE


Ikona (ICON)[edytuj]

GUICtrlCreateIcon ( "Nazwa_pliku", ID_ikony, x, y [, szerokość [, wysokość [, style [, exStyle]]]] )

Funkcja tworzy kontrolkę w postaci ikony.

Zwraca ID tworzonej kontrolki lub 0 gdy wystąpił błąd.

"nazwa pliku"- nazwa pliku ikony wraz ze ścieżką dostępu.

ID_ikony - numer ikony w pliku ikon (jeżeli plik zawiera bibliotekę ikon), domyślnie -1

x i y - położenie wewnątrz okna GUI (w pikselach).

Pozostałe parametry opcjonalne:

szerokość i wysokość - wielkość pola kontrolki (w pikselach, domyślnie 32), ikona jest skalowana do wielkości okna.

style i exstyle - parametry określające styl kontrolki.

Przykład:

#include <GUIConstantsEx.au3>
GUICreate(" My GUI Icons", 250, 250)
$icon = GUICtrlCreateIcon("shell32.dll", 21, 20, 20)
$n1 = GUICtrlCreateIcon(@WindowsDir & "\cursors\horse.ani", -1, 20, 60)
$n2 = GUICtrlCreateIcon("shell32.dll", 16, 20, 100, 100, 80, 0x1000)
GUISetState()
Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE


Okienka wprowadzania (INPUT)[edytuj]

GUICtrlCreateInput ( "tekst", x, y [, szerokość [, wysokość [, style [, exStyle]]]] )

Funkcja tworzy kontrolkę w postaci okienka, w którym można wpisywać i edytować wiersz tekstu.

Zwraca ID tworzonej kontrolki lub 0 gdy wystąpił błąd.

"tekst" - początkowy tekst w okienku.

x i y - położenie wewnątrz okna GUI (w pikselach).

Pozostałe parametry opcjonalne:

szerokość i wysokość - wielkość pola kontrolki (w pikselach).

style i exstyle - parametry określające styl kontrolki.

UWAGA: Odczyt tekstu z okienka przy użyci funkcji GUICtrlRead, zmiana tekstu funkcją GUICtrlSetData.

Kilka użytecznych wartości parametru style, nazwy stałych wg <EditConstants.au3>:

Nazwa stałej  | Wartość hex | Opis
----------------------------------------------------------------------
$ES_CENTER    |         0x1 | Centrowanie tekstu
$ES_RIGHT     |         0x2 | Wyrównanie do prawej
$ES_UPPERCASE |         0x8 | Zamiana wszystkich liter na wielkie
$ES_LOWERCASE |        0x10 | Zamiana wszystkich liter na małe
$ES_PASSWORD  |        0x20 | Maskowanie wprowadzanych znaków (*)
$ES_READONLY  |       0x800 | Tylko do odczytu (nie można edytować)
$ES_NUMBER    |      0x2000 | Można wprowadzać tylko cyfry

Wartości parametru można sumować np.:0x1+0x8+0x20

Przykład:

#include <GUIConstantsEx.au3>
GUICreate("Wprowadź tekst",300,200,-1,250)
$f1=GUICtrlCreateInput("", 10, 5, 200, 20,0x1000)
$f2=GUICtrlCreateInput("999", 10, 35, 200, 20,0x29)
$btn = GUICtrlCreateButton("Ok", 40, 75, 60, 20)
GUISetState()

Do
   $msg = GUIGetMsg()
   $txt1= GUICtrlRead($f1)
   $txt2= GUICtrlRead($f2)
   If $msg = $btn Then ExitLoop
Until $msg=$GUI_EVENT_CLOSE
MsgBox(4096, "","Wprowadziłes: '"&$txt1&"'  i  '"&$txt2&"'")


Etykietka (LABEL)[edytuj]

GUICtrlCreateLabel ( "tekst", x, y [, szerokość [, wysokość [, style [, exStyle]]]] )

Funkcja tworzy kontrolkę w postaci etykietki.

Zwraca ID tworzonej kontrolki lub 0 gdy wystąpił błąd.

"tekst" - tekst na etkietce.

x i y - położenie wewnątrz okna GUI (w pikselach).

Pozostałe parametry opcjonalne:

szerokość i wysokość - wielkość pola kontrolki (w pikselach).

style i exstyle - parametry określające styl kontrolki.

style:
-------------------------------------------------------------------
     0 | wyrównanie do lewej, za długie wiersze zawijane (domyślne)
     1 | centrowanie, za długie wiersze zawijane
     2 | wyrównanie do prawej, za długie wiersze zawijane
   0xC | wyrównanie do lewej, za długie wiersze obcinane
0x1000 | ramka

Zmiana tekstu za pomocą funkcji GUICtrlSetData.

Kolor tła i czcionki można ustawić za pomocą GUICtrlSetBkColor i GUICtrlSetColor, rodzaj czcionki GUICtrlSetFont.

Przykład:

#include <GUIConstantsEx.au3>
GUICreate("Etykietka (LABEL):")
$lab=GUICtrlCreateLabel("Tekst na etykietce"&@LF&"a to drugi wiersz", 100, 100,150,100,0x1001)
GUICtrlSetBkColor($lab,0xffff00)         ;kolor tła okienka
GUICtrlSetColor($lab,0xff0000)           ;kolor czcionki
GUISetState()

Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE

GUICtrlSetBkColor($lab,0x000000)         ;zmiana koloru tła okienka
GUICtrlSetColor($lab,0xffff00)           ;zmiana koloru czcionki
GUICtrlSetFont($lab,16,Default,Default,"Comic Sans MS") ;zmiana czcionki
GUICtrlSetData($lab,"A teraz"&@LF&"nowy tekst"&@LF&"na etykietce!") ;zmiana tekstu

Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE


Lista (LIST)[edytuj]

GUICtrlCreateList ( "tekst", x, y [, szerokość [, wysokość [, style [, exStyle]]]] )

Funkcja tworzy kontrolkę w postaci listy, a w zasadzie pierwszą jej pozycję. Kolejne pozycje tworzone są za pomocą funkcji GUICtrlSetData.

Zwraca ID tworzonej kontrolki lub 0 gdy wystąpił błąd.

"tekst" - tekst pierwszej pozycji listy.

x i y - położenie wewnątrz okna GUI (w pikselach).

Pozostałe parametry opcjonalne:

szerokość i wysokość - wielkość pola kontrolki (w pikselach).

style i exstyle - parametry określające styl kontrolki.

style = 2        - sortowanie alfabetyczne pozycji listy
style = 0xa00000 - przycisk góra/dół jeżeli pozycje nie mieszczą się w okienku

Przykład:

#include <GUIConstantsEx.au3>
GUICreate("Lista:",-1,-1,550)
$lista = GUICtrlCreateList("Pozycja 2", 100, 32, 120, 45, 0xa00002)
GUICtrlSetData(-1, "Pozycja 3")
GUICtrlSetData(-1, "Pozycja 4")
GUICtrlSetData(-1, "Pozycja 1")
$odczyt = GUICtrlCreateButton("Odczyt", 64, 170, 175, 25)
GUISetState()
Do
$msg = GUIGetMsg()
   If $msg=$odczyt Then MsgBox(0,"Wybrano:", GUICtrlRead($lista))
Until $msg = $GUI_EVENT_CLOSE


Tabela (LIST_VIEW)[edytuj]

GUICtrlCreateListView ( "tekst", x, y [, szerokość [, wysokość [, style [, exStyle]]]] )

Funkcja tworzy kontrolkę w postaci tabeli, a w zasadzie pierwszy wiersz z nazwani kolumn. Kolejne wiersze tabeli tworzone są za pomocą funkcji GUICtrlCreateListViewItem.

Zwraca ID tworzonej kontrolki lub 0 gdy wystąpił błąd.

"tekst" - tekst z nazwami kolumn, nazwy poszczególnych kolumn rozdziela się znakiem pionowej kreski (np.: "Nazwisko | Imię | Wiek").

x i y - położenie wewnątrz okna GUI (w pikselach).

Pozostałe parametry opcjonalne:

szerokość i wysokość - wielkość pola kontrolki (w pikselach).

style i exstyle - parametry określające styl kontrolki.


Tworzenie wierszy tabeli (LIST_VIEW_ITEM)[edytuj]

GUICtrlCreateListViewItem ( "tekst", listviewID )

Funkcja tworzy kolejny wiersz tabeli LIST_VIEW.

Zwraca ID tworzonej kontrolki lub 0 gdy wystąpił błąd.

"tekst" - tekst z zawartością kolejnych kolumn tabeli, poszczególnych kolumn rozdziela się znakiem pionowej kreski (np.: "Kowalski | Jan | 44").

listviewID - ID tabeli utworzonej przez GUICtrlCreateListView.

Usuwanie wierszy za pomocą funkcji GUICtrlDelete, zmiana zawartości wiersza GUICtrlSetData, odczyt zawartości wiersza GUICtrlRead.

UWAGA: - domyślny separator (|) można zmienić na inny za pomocą funkcji AutoItSetOption lub Opt (np.: Opt("GUIDataSeparatorChar","#")).

Przykład:

#include <GUIConstantsEx.au3>
GUICreate("LISTVIEW", 300, 250, 500, 200)
$listview = GUICtrlCreateListView("kolumna 1 | kolumna 2 | kolumna 3", 10, 10, 260, 100)
$item1 = GUICtrlCreateListViewItem("poz.11|poz.21|poz.31", $listview)
$item2 = GUICtrlCreateListViewItem("poz.12|poz.22|poz.32", $listview)
$item3 = GUICtrlCreateListViewItem("poz.13|poz.23|poz.33", $listview)
$button = GUICtrlCreateButton("Wybrano", 75, 170, 70, 20)
GUISetState()
Do
   $msg = GUIGetMsg()
   If $msg=$listview Then MsgBox(0, "Wybrano:", GUICtrlGetState($listview))
   If $msg=$button Then MsgBox(0, "Wybrano:", GUICtrlRead(GUICtrlRead($listview)))
Until $msg = $GUI_EVENT_CLOSE


Menu rozwijane (MENU)[edytuj]

GUICtrlCreateMenu ( "tekst" [, ID [, nr]] )

Funkcja tworzy menu rozwijane. Zwraca ID tworzonej kontrolki lub 0 gdy wystąpił błąd.

"tekst" - tekst na pozycji manu (string pusty "" oznacza separator, & oznacza że następny znak jest tzw. gorącym klawiszem, którego naciśnięcie powoduje wybranie danej pozycji menu).

ID - ID pozycji nadrzędnej menu. Jeżeli nie podamy to utworzona zostanie pierwsza pozycja menu rozwijanego (pozycja widoczna pod belką okna).

nr - pozwala nadać numer pozycji manu. Pozycje są numerowane zaczynając od 0. Domyślnie numerowanie jest kolejnością wpisu w treści programu. Za pomocą tego numeru można zmienić kolejność pozycji w menu bez konieczności przestawiania wpisów w programie.

Pozycje podmenu tworzymy funkcją:

GUICtrlCreateMenu - jeżeli dana pozycja ma zawierać podmenu.

GUICtrlCreateMenuItem - jeżeli dana pozycja nie zawiera podmenu.

UWAGA: Funkcja służy także do tworzenia pozycji w menu kontekstowym (CONTEXT_MENU).

Przykład:

#include <GUIConstantsEx.au3>

GUICreate("Menu rozwijane:", 300, 300)
$menu=GUICtrlCreateMenu("Menu okna")                        ;utworzenie menu okna
$item1=GUICtrlCreateMenuItem("Zamknięcie okna",$menu)       ;nie zawiera podmenu
GUICtrlSetState(-1, $GUI_DISABLE)                           ;nieaktywna pozycja menu
GUICtrlCreateMenuItem("", $menu)                            ;separator
$item2=GUICtrlCreateMenu("Kolor tła okna",$menu)            ;zawiera podmenu
$item21=GUICtrlCreateMenuItem("Zielone",$item2)             ;podmenu
$item22=GUICtrlCreateMenuItem("Niebieskie",$item2)          ;podmenu

$lab=GUICtrlCreateLabel("Przykładowy tekst"&@LF&"na etykietce", 50, 100,200,100,0x1001)
GUICtrlSetFont($lab,16,Default,Default,"Comic Sans MS")
$labmenu=GUICtrlCreateMenu("Menu kontrolki")                ;menu kontrolki
$labitem1=GUICtrlCreateMenu("Kolor tła", $labmenu)
$labitem11=GUICtrlCreateMenuItem("&W Białe", $labitem1)
$labitem12=GUICtrlCreateMenuItem("&Y Żółte", $labitem1)
$labitem2=GUICtrlCreateMenu("Kolor czcionki", $labmenu)
$labitem21=GUICtrlCreateMenuItem("&B Czarna", $labitem2)
$labitem22=GUICtrlCreateMenuItem("&R Czerwona", $labitem2)
GUISetState()
Do
$msg=GUIGetMsg()
   If $msg=$item1 Then ExitLoop
   If $msg=$item21 Then
      GUISetBkColor(0x00ff00)
	  GUICtrlSetState($item21, $GUI_CHECKED)           ;odhaczenie pozycji
	  GUICtrlSetState($item22, $GUI_UNCHECKED)         ;usunięcie odhaczenia
   EndIf
   If $msg=$item22 Then
	  GUISetBkColor(0x0000ff)
	  GUICtrlSetState($item22, $GUI_CHECKED)
	  GUICtrlSetState($item21, $GUI_UNCHECKED)
   EndIf
   If $msg=$labitem11 Then GUICtrlSetBkColor($lab, 0xffffff)
   If $msg=$labitem12 Then GUICtrlSetBkColor($lab,0xffff00)
   If $msg=$labitem21 Then GUICtrlSetColor($lab,-1)
   If $msg=$labitem22 Then GUICtrlSetColor($lab,0xff0000)
Until $msg=$GUI_EVENT_CLOSE


Pozycja menu rozwijanego lub kontekstowego (MENU_ITEM)[edytuj]

GUICtrlCreateMenuItem ( "tekst", ID [, nr [, menuradioitem]] )

Funkcja tworzy pozycję w menu rozwijanym lub kontekstowym. Zwraca ID tworzonej kontrolki lub 0 gdy wystąpił błąd.

"tekst" - tekst na pozycji manu (string pusty "" oznacza separator, & oznacza że następny znak jest tzw. gorącym klawiszem, którego naciśnięcie powoduje wybranie danej pozycji menu).

ID - ID pozycji nadrzędnej menu. Jeżeli nie podamy to utworzona zostanie pierwsza pozycja menu rozwijanego (pozycja widoczna pod belką okna).

nr - pozwala nadać numer pozycji manu. Pozycje są numerowane zaczynając od 0. Domyślnie numerowanie jest kolejnością wpisu w treści programu. Za pomocą tego numeru można zmienić kolejność pozycji w menu bez konieczności przestawiania wpisów w programie.

menuradioitem - rodzaj kontrolki: 0 - normalna (domyślnie), 1 - z RADIO_ITEM.

Przykład (z RADIO_ITEM):

#include <GUIConstantsEx.au3>

GUICreate("MENU_ITEM:", 300, 300)
$menu=GUICtrlCreateMenu("Menu 1")
$item1=GUICtrlCreateMenuItem("Poz.1",$menu,Default,1)
$item2=GUICtrlCreateMenuItem("Poz.2",$menu,Default,1)
GUISetState()
GUICtrlSetState($item1,$GUI_CHECKED)
Do
$msg=GUIGetMsg()
Until $msg=$GUI_EVENT_CLOSE


Kalendarz (MONTH_CAL)[edytuj]

GUICtrlCreateMonthCal ( "data", x, y [, szerokość [, wysokość [, style [, exStyle]]]] )

Funkcja tworzy kalendarz z datami jednego miesiąca. Zwraca ID tworzonej kontrolki lub 0 gdy wystąpił błąd.

"data" - string daty w formacie rrrr/mm/dd, string pusty oznacza aktualną datę (wg zegara systemowego).

x i y - położenie wewnątrz okna GUI (w pikselach).

Pozostałe parametry opcjonalne:

szerokość i wysokość - wielkość pola kontrolki (w pikselach).

style i exstyle - parametry określające styl kontrolki.

style = 0x4   - numery tygodni kalendarzowych 
style = 0x8   - bez ramki wokół aktualnego dnia
style = 0x10  - bez aktualnej daty na dole okienka
--------------------------------------------------
exstyle = 0   - okienko bez ramki

UWAGA: Odczyt wybranej daty przy użyciu funkcji GUICtrlRead, ustawianie daty funkcją GUICtrlSetData.

Przykład:

#include <GUIConstantsEx.au3>

GUICreate("Wybierz datę:", 220, 190)
$Date = GUICtrlCreateMonthCal("1952/12/22", 25, 20,-1,-1,0xC,0)
GUISetState()
Do
   $msg = GUIGetMsg()
   If $msg = $Date Then MsgBox(0, "Data:", GUICtrlRead($Date))
Until $msg = $GUI_EVENT_CLOSE



Obrazek (PICTURE)[edytuj]

GUICtrlCreatePic ( "nazwa_pliku", x, y [, szerokość [, wysokość [, style [, exStyle]]]] )

Funkcja tworzy kontrolkę zawierającą obrazek. Zwraca ID tworzonej kontrolki lub 0 gdy wystąpił błąd.

"nazwa_pliku" - nazwa pliku obrazka (może być ze ścieżką dostępu). Obrazek może być w formacie BMP, JPG, PNG, GIF (nieanimowany).

x i y - położenie wewnątrz okna GUI (w pikselach).

Pozostałe parametry opcjonalne:

szerokość i wysokość - wielkość pola kontrolki (w pikselach).

style i exstyle - parametry określające styl kontrolki.

Zmiana obrazka za pomocą funkcji GUICtrlSetImage.

UWAGA: Obrazek jest skalowany do wielkości okna kontrolki. Jeżeli chcemy uzyskać obrazek w jego oryginalnej wielkości należy podać szerokość i wysokość równą 0.

Przykład:

#include <GUIConstantsEx.au3>

GUICreate("Obrazek:", 300, 300)
$sPic = FileOpenDialog("Wybierz plik", "", "Obrazki(*.jpg; *.gif; *.bmp)", 4)
GUISetState()
$hPic = GUICtrlCreatePic($sPic, 50, 50, 200, 200)
Sleep(2000)
GUICtrlDelete($hPic)
$hPic = GUICtrlCreatePic($sPic, 25, 50, 250, 100)
Sleep(2000)
GUICtrlDelete($hPic)
GUICtrlCreatePic($sPic, 100, 25, 100, 250)
Sleep(2000)

Pasek postępu (PROGRES)[edytuj]

GUICtrlCreateProgress ( x, y [, szerokość [, wysokość [, style [, exStyle]]]] )

Funkcja tworzy kontrolkę z paskiem postępu. Zwraca ID kontrolki lub 0 gdy wystąpił błąd.

x i y - położenie wewnątrz okna GUI (w pikselach).

Pozostałe parametry opcjonalne:

szerokość i wysokość - wielkość pola kontrolki (w pikselach).

style i exstyle - parametry określające styl kontrolki.

style = 1    - gładkie przewijanie (domyślnie skokowe)
style = 4    - pasek pionowy (domyślnie poziomy)
-----------------------------------------------------
exstyle = 1  - z wypukłą ramką

Przykład:

#include <GUIConstantsEx.au3>
GUICreate("Pasek postępu:", 500, 250)
$hProgressbar1 = GUICtrlCreateProgress(450, 10, 20, 200,4,1) ;pionowy z ramką
$hProgressbar2 = GUICtrlCreateProgress(20, 40, 400, 20)
$hButton = GUICtrlCreateButton("Start", 100, 170, 70, 20)
GUISetState()
Do
   $msg = GUIGetMsg()
   If $msg = $hButton Then
      GUICtrlSetState($hButton,$GUI_DISABLE) ;przycisk nieaktywny
      For $i = 0 To 100
         GUICtrlSetData($hProgressbar1, $i)
         GUICtrlSetData($hProgressbar2, (100 - $i))
         Sleep(30)
      Next
      GUICtrlSetState($hButton,$GUI_ENABLE) ;przycisk aktywny
   EndIf
Until $msg = $GUI_EVENT_CLOSE

Przełącznik (RADIO_BUTTON)[edytuj]

GUICtrlCreateRadio  ( "tekst", x, y [, szerokość [, wysokość [, style [, exStyle]]]] )

Funkcja tworzy tworzy przełącznik RADIO_BUTTON. Przełącznik ten zwykle występuje w grupach. Tylko jeden przełącznik w grupie może być włączony. Zaznaczenie jednego przełącznika w grupie powoduje automatyczne zresetowanie wszystkich pozostałych.

Zwraca ID tworzonej kontrolki lub 0 gdy wystąpił błąd.

"tekst" - tekst obok kontrolki.

x i y - położenie wewnątrz okna GUI (w pikselach).

Pozostałe parametry opcjonalne:

szerokość i wysokość - wielkość pola kontrolki (w pikselach).

style i exstyle - parametry określające styl kontrolki.

Tworzenie grup kontrolek za pomocą funkcji GUIStartGroup lub GUICtrlCreateGroup.

UWAGA: Jeżeli nie użyjemy funkcji tworzących grupy kontrolek to wszystkie kontrolki RADIO_BUTTON będą domyślnie stanowiły jedną grupę.

Przykład:

#include <GUIConstantsEx.au3>

GUICreate("Przełączniki RADIO:")
$hRadio1 = GUICtrlCreateRadio("Radio 1", 20, 10, 120, 20)
$hRadio2 = GUICtrlCreateRadio("Radio 2", 20, 40, 120, 20)
$hRadio3 = GUICtrlCreateRadio("Radio 3", 20, 70, 120, 20)
GUICtrlSetState($hRadio2, $GUI_CHECKED)          ;aktywny przełącznik
GUISetState()
Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE
If GUICtrlRead($hRadio1)=$GUI_CHECKED Then MsgBox(64,"Zaznaczono:","Radio 1",3)
If GUICtrlRead($hRadio2)=$GUI_CHECKED Then MsgBox(64,"Zaznaczono:","Radio 2",3)
If GUICtrlRead($hRadio3)=$GUI_CHECKED Then MsgBox(64,"Zaznaczono:","Radio 3",3)

Suwak (SLIDER)[edytuj]

GUICtrlCreateSlider ( x, y [, szerokość [, wysokość [, style [, exStyle]]]] )

Funkcja tworzy kontrolkę z suwakiem. Zwraca ID kontrolki lub 0 gdy wystąpił błąd.

x i y - położenie wewnątrz okna GUI (w pikselach).

Pozostałe parametry opcjonalne:

szerokość i wysokość - wielkość pola kontrolki (w pikselach).

style i exstyle - parametry określające styl kontrolki.

style =    0   - bez skali
style =    1   - ze skalą, poziomy, wskaźnik w dół (domyślnie)
style =    2   - pionowy, wskaźnik w prawo
style =    4   - kierunek wskaźnika odwrócony
style =    8   - wskaźnik prostokątny
style = 0x10   - bez skali i znaczników zakresu przesuwu
style = 0x80   - wskaźnik suwaka niewidoczny
-------------------------------------------------------------
exstyle =   0x200 - ramka
exstyle = 0x20000 - półramka

Przykład:

#include <GUIConstantsEx.au3>

GUICreate("Suwak (0-255):", 250, 100, 600, 300)
$slider = GUICtrlCreateSlider(10, 10, 230, 40,-1, 0x200)
GUICtrlSetLimit(-1, 0xff, 0)   ;ustawienie zakresu wartosci
$button = GUICtrlCreateButton("Wartosć", 75, 70, 70, 20)
GUISetState()
Do
   $msg = GUIGetMsg()
   If $msg = $button Then
      MsgBox(0, "Suwak:", GUICtrlRead($slider), 2)
   EndIf
Until $msg = $GUI_EVENT_CLOSE


Zakładka (TAB)[edytuj]

GUICtrlCreateTab ( x, y [, szerokość [, wysokość [, style [, exStyle]]]] )

Funkcja tworzy kontrolkę w postaci pola na zakładki. Poszczególne zakładki tworzone są funkcją GUICtrlCreateTabItem.

Funkcja zwraca ID kontrolki lub 0 gdy wystąpił błąd.

x i y - położenie wewnątrz okna GUI (w pikselach).

Pozostałe parametry opcjonalne:

szerokość i wysokość - wielkość pola kontrolki (w pikselach).

style i exstyle - parametry określające styl kontrolki.


Tworzenie zakładek (TAB_ITEM)[edytuj]

GUICtrlCreateTabItem ( "tekst" )

Funkcja tworzy zakładki w polu utworzonym przez GUICtrlCreateTab. Zwraca ID kontrolki lub 0 gdy wystąpił błąd.

"tekst" - tekst na zakładce. String pusty oznacza zakończenie definicji zakładek.

UWAGA: Wewnątrz zakładek można umieszczać inne kontrolki. Będą one dostępne tylko wtedy gdy dana zakładka jest aktywna.

Przykład:

#include <GUIConstantsEx.au3>

GUICreate("Zakładki:")
$tab = GUICtrlCreateTab(10, 10, 200, 100)    ;przygotowanie okienka na zakładki

;początek definicji zakładek
$tab1 = GUICtrlCreateTabItem("Zakładka 1")                  ;tworzenie zakładki
GUICtrlCreateLabel("Etykietka 1", 30, 80, 60, 20)    ;3 kontrolki na zakładkach
$tab1OK = GUICtrlCreateButton("OK", 20, 50, 50, 20)
$tab1input = GUICtrlCreateInput("Propozycja tekstu", 80, 50, 100, 20)

$tab2 = GUICtrlCreateTabItem("Zakładka 2")
GUICtrlCreateLabel("Etykietka 2", 30, 80, 60, 20)
$tab2combo = GUICtrlCreateCombo("", 20, 50, 80, 100)
GUICtrlSetData(-1, "Adam|Cezary|Jan|Ludwik|Waldemar", "Waldemar")
$tab2OK = GUICtrlCreateButton("OK", 110, 50, 50, 20)

$tab3 = GUICtrlCreateTabItem("Zakładka 3")
GUICtrlSetState(-1, $GUI_SHOW) 	                              ;zakładka bieżąca
GUICtrlCreateLabel("Etykietka 3", 30, 80, 60, 20)
$tab3OK = GUICtrlCreateButton("OK", 140, 50, 50)

GUICtrlCreateTabItem("") 	                    ;koniec definicji zakładek

GUICtrlCreateLabel("Etykietka 4", 20, 130, 60, 20) ;kontrolka po za zakładkami

GUISetState()
Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE


Drzewo (TREE_VIEW)[edytuj]

GUICtrlCreateTreeView  ( x, y [, szerokość [, wysokość [, style [, exStyle]]]] )

Funkcja tworzy kontrolkę w postaci pola pod drzewo. Poszczególne zakładki tworzone są funkcją GUICtrlCreateTreeViewItem.

Funkcja zwraca ID kontrolki lub 0 gdy wystąpił błąd.

x i y - położenie wewnątrz okna GUI (w pikselach).

Pozostałe parametry opcjonalne:

szerokość i wysokość - wielkość pola kontrolki (w pikselach).

style i exstyle - parametry określające styl kontrolki.

style = 0x005  - tylko przyciski +-
style = 0x007  - przyciski +- i linie łączące
------------------------------------------------
dodanie 0x100  - dodatkowo pole CHECKBOX


Tworzenie gałęzi drzewa (TREE_VIEW_ITEM)[edytuj]

GUICtrlCreateTreeViewItem ( "tekst", treeviewID )

Funkcja tworzy gałęzie drzewa w polu utworzonym przez GUICtrlCreateTreeView. Zwraca ID kontrolki lub 0 gdy wystąpił błąd.

"tekst" - tekst obok kontrolki.

treeviewID - ID gałęzi nadrzędnej drzewa

Przkład:

#include <GUIConstantsEx.au3>
#include <TreeViewConstants.au3>

GUICreate("TREE_VIEW:", 300, 300)
$treeOne=GUICtrlCreateTreeView(90, 50, 120, 150)
$treeItem1=GUICtrlCreateTreeViewItem("Drzewo 1", $treeOne)
$treeItem11=GUICtrlCreateTreeViewItem("Poz.1", $treeItem1)
$treeItem12=GUICtrlCreateTreeViewItem("Poz.2", $treeItem1)
$treeItem121=GUICtrlCreateTreeViewItem("Poz.21", $treeItem12)
$treeItem122=GUICtrlCreateTreeViewItem("Poz.22", $treeItem12)
$treeItem2=GUICtrlCreateTreeViewItem("Drzewo 2", $treeOne)
$treeItem21=GUICtrlCreateTreeViewItem("Poz.21", $treeItem2)
GUICtrlSetState($treeItem2, $GUI_EXPAND)   ;gałąź rozwinęta

$button=GUICtrlCreateButton(" Odczyt ",120,260)

GUISetState()
Do
   $msg=GUIGetMsg()
   If $msg=$button Then MsgBox(0,"Wybrano:",GUICtrlRead($treeOne,1))
Until $msg = $GUI_EVENT_CLOSE


Góra / Dół (UP_DOWN)[edytuj]

GUICtrlCreateUpdown ( inputID [,style] )

Funkcja tworzy kontrolkę z przyciskami góra/dół. Kontrolka jest zawsze związana z kontrolką INPUT. Służy do zwiększanie lub zmniejszania wartości w okienku wprowadzania. Zwraca ID kontrolki lub 0 gdy wystąpił błąd.

inputID - ID kontrolki INPUT

style - parametr określający styl kontrolki.

style = 0x01  - zawijanie wartości po przekroczeniu ustawionego zakresu 
style = 0x04  - kontrolka z prawej strony (domyślne)
style = 0x08  - kontrolka z lewej strony
style = 0x20  - aktywne klawisze strzałka w górę/dół na klawiaturze
style = 0x40  - układ poziomy przycisków
style = 0x80  - bez spacji między co trzecią cyfrą dziesiętną

Ustawienie zakresu wartości za pomocą funkcji GUICtrlSetLimit .

Przykład:

#include <GUIConstantsEx.au3>

GUICreate("Góra / Dół:")
$input = GUICtrlCreateInput("44", 20, 20, 100, 25, 0x800)
$updown = GUICtrlCreateUpdown($input, 0x21)
GUICtrlSetLimit($updown,100)  ;limit wartości (0 - 100)

GUISetState()
Do
Until GUIGetMsg()=$GUI_EVENT_CLOSE
MsgBox(0, "Updown", GUICtrlRead($input))


Odczyt uchwytu kontrolki[edytuj]

GUICtrlGetHandle ( [ID_kontrolki] )

Funkcja zwraca uchwyt do kontrolki, lub 0 gdy wystąpił błąd.

ID_kontrolki - numer identyfikacyjny (ID) kontrolki, domyślnie kontrolka bieżąca.

UWAGA:

1. Nie są obsługiwane kontrolki typu: Dummy, Graphic, Object, ListViewItem i TabItem.

2. Uzyskanie uchwytu do kontrolki umożliwia odwołanie się do niej także z po za skryptu, np. w funkcji biblioteki DLL.

Więcej o użyciu biblitek DLL w rozdziale AutoIt/Biblioteki DLL .

Przykład - zmiana koloru tła menu za pomocą funkcji systemu operacyjnego z biblioteki DLL (gdi32.dll):

#include <GUIConstantsEx.au3>

GUICreate("Test GUICtrlGetHandle:", 300, 200, -1, -1, 0)
$FileMenu = GUICtrlCreateMenu("&Plik")
GUICtrlCreateMenuItem("&Otwórz", $FileMenu)
GUICtrlCreateMenuItem("&Zapisz", $FileMenu)
GUICtrlCreateMenuItem("", $FileMenu)

$OptionsMenu = GUICtrlCreateMenu("O&pcje", $FileMenu)
GUICtrlCreateMenuItem("Wyświetl", $OptionsMenu)
GUICtrlCreateMenuItem("", $OptionsMenu)
GUICtrlCreateMenuItem("Narzędzia", $OptionsMenu)
GUICtrlCreateMenuItem("", $FileMenu)
$ExitItem = GUICtrlCreateMenuItem("&Koniec", $FileMenu)
$HelpMenu = GUICtrlCreateMenu("&?")
$AboutItem = GUICtrlCreateMenuItem("&O programie", $HelpMenu)

SetMenuColor($FileMenu, 0xEEBB99)
SetMenuColor($OptionsMenu, 0x66BB99)
SetMenuColor($HelpMenu, 0x99BBEE)

GUISetState()

Do
   $Msg = GUIGetMsg()
   Switch $Msg
      Case $ExitItem, $GUI_EVENT_CLOSE
         ExitLoop
      Case $AboutItem
         MsgBox(64, "O programie:", "Zmiana kolorów menu.")
   EndSwitch
Until 0

Func SetMenuColor($ID, $color)
   Local $hMenu = GUICtrlGetHandle($ID)
   Local $hBrush = DllCall("gdi32.dll", "hwnd", "CreateSolidBrush", "int", $color)
   Local $stMenuInfo = DllStructCreate("dword;dword;dword;uint;ptr;dword;ptr")
   DllStructSetData($stMenuInfo, 1, DllStructGetSize($stMenuInfo))
   DllStructSetData($stMenuInfo, 2, BitOR(0x80000000, 2))
   $hBrush = $hBrush[0]
   DllStructSetData($stMenuInfo, 5, $hBrush)
   DllCall("user32.dll", "int", "SetMenuInfo", "hwnd", $hMenu, "ptr", DllStructGetPtr($stMenuInfo))
EndFunc


Odczyt statusu kontrolki[edytuj]

GUICtrlGetState ( [ID_kontrolki] )

Funkcja zwraca status kontrolki lub -1 gdy kontrolka nie istnieje.

ID_kontrolki - numer identyfikacyjny (ID) kontrolki, domyślnie kontrolka bieżąca

UWAGA: Funkcja ma działanie zbliżone do GUICtrlRead, ale nie zwraca danych z kontrolki, tylko i wyłącznie stany: enabled/disabled/hidden/show/dropaccepted. Są to statusy związane z właściwościami kontrolki, a nie ze stanem jej użycia. Wartości statusów jak dla GUICtrlSetState.

Przykład obrazujący różnicę między GUICtrlRead a GUICtrlGetState:

#include <GUIConstantsEx.au3>

GUICreate("GUICtrlGetState")
$n = GUICtrlCreateCheckbox("checkbox", 20, 100)
GUICtrlSetState(-1, $GUI_CHECKED) 	; checked

GUISetState()
Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE
MsgBox(0,"","GUICtrlRead = "&GUICtrlRead($n)&@LF&"GUICtrlGetState = "&Hex(GUICtrlGetState($n)))
;GUICtrlRead zwraca 1 czyli kontrolka zaznaczona
;GUICtrlGetState zwraca 0x50 czyli kontrolka aktywna i widoczna (0x40 + 0x10)


Ustawienie statusu kontrolki[edytuj]

GUICtrlSetState ( ID_kontrolki, status )

Funkcja ustawia status kontrolki. Zwraca 1 gdy sukces, lub 0 gdy wystąpił błąd (np. kontrolka nie istnieje).

ID_kontrolki - numer identyfikacyjny (ID) kontrolki, -1 oznacza ostatnio utworzoną kontrolkę.

status - status kontrolki wg poniższej tabeli:

Nazwa stałej wg     |Wartość|
<GUIConstantsEx.au3>|  Hex  | Opis
-------------------------------------------------------------------------------------------------------
0                   |      0| bez zmian
$GUI_UNCHECKED      |      4| kontrolka niezaznaczona (RADIO, CHECKBOX, LIST_VIEW_ITEM) 
$GUI_CHECKED        |      1| kontrolka zaznaczona (RADIO, CHECKBOX, LIST_VIEW_ITEM)
$GUI_INDETERMINATE  |      2| stan nieokreślony (CHECKBOX)
$GUI_AVISTART       |      1| animacja działająca (AVI)
$GUI_AVISTOP        |      0| animacja wstrzymana (AVI)
$GUI_AVICLOSE       |      2| animacja zatrzymana, zasoby zwolnione (AVI)
$GUI_DROPACCEPTED   |      8| przyjmuje dane metodą "drag&drop" (EDIT/INPUT)
$GUI_NODROPACCEPTED | 0x1000| odwołanie $GUI_NODROPACCEPTED
$GUI_SHOW           |   0x10| kontrolka widoczna (dla TAB_ITEM widoczna pierwsza zakładka)
$GUI_HIDE           |   0x20| kontrolka niewidoczna
$GUI_ENABLE         |   0x40| kontrolka aktywna
$GUI_DISABLE        |   0x80| kontrolka nieaktywna (wyświetlana na szaro, nie można zmieniać jej stanu)
$GUI_FOCUS          |  0x100| kontrolka "podświetlona" (bieżąca)
$GUI_NOFOCUS        | 0x2000| odwołanie $GUI_FOCUS
$GUI_DEFBUTTON      |  0x200| kontrolka wybrana, dla TREE_VIEW_ITEM tekst wyróżniony pogrubieniem
$GUI_EXPAND         |  0x400| gałęzie podrzędne rozwinięte (COMBO, TREE_VIEW_ITEM) 
$GUI_ONTOP          |  0x800| atrybut "na wierzchu"

Statusy można sumować, np.: $GUI_CHECKED + $GUI_DISABLE oznacza kontrolkę zaznaczoną i nieaktywną.

Nie można zmieniać statusów w CONTEXT_MENU. MENU i MENU_ITEM nie może mieć statusu niewidoczne ($GUI_HIDE).

Aby działało $GUI_DROPACCEPTED należy przy tworzeniu okna GUI funkcją GUICreate ustawić exstyle = $WS_EX_WINDOWEDGE (wg <WindowsConstants.au3>).

Po przeciągnięciu do jakiegoś obiektu do kontrolki, pojawi się w niej nazwa pliku wraz z pełną ścieżką dostępu.

Przykład 1:

#include <GUIConstantsEx.au3>

GUICreate("GuiCtrlSetState:")
GUICtrlCreateLabel('Etykietka "na szaro"', 10, 20)
GUICtrlSetState(-1, $GUI_DISABLE)

GUICtrlCreateCheckbox("ble ble",10,150)
GUICtrlSetState(-1, $GUI_CHECKED)         ;kontrolka zaznaczona
GUICtrlCreateCheckbox("raz dwa",10,170)

$hListview = GUICtrlCreateListView("kolumna 1 | kolumna 2 | kolumna 3", 10, 200, 260, 100)
GUICtrlSetState($hListview, $GUI_DISABLE)                     ;kontrolka nieaktywna
GUICtrlCreateListViewItem("poz.11|poz.21|poz.23", $hListview)
GUICtrlCreateListViewItem("poz.21|poz.22|poz.23", $hListview)
GUICtrlCreateListViewItem("poz.31|poz.32|poz.33", $hListview)

$hButton=GUICtrlCreateButton("Przycisk: KONIEC", 50, 50)
GUICtrlSetState(-1, $GUI_FOCUS)            ;kontrolka podświetlona

GUISetState()
Do
   $iMsg = GUIGetMsg()
Until  $iMsg = $GUI_EVENT_CLOSE Or $iMsg = $hButton


Przykłąd 2 (drag&drop):

#include <GUIConstantsEx.au3>
#include <WindowsConstants.au3>

GUICreate("Drag&Drop", 450, 100, 800, 250,-1,$WS_EX_ACCEPTFILES)
GUICtrlCreateLabel("Przeciągnij obiekt do okienka:",10,10)
$hInput = GUICtrlCreateInput("",10,30,430,20)
GUICtrlSetState(-1, $GUI_DROPACCEPTED)      ;akceptacja drag&drop
GUISetState()
Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE
MsgBox(0, "Path:", GUICtrlRead($hInput))

Kolor tła kontrolki[edytuj]

GUICtrlSetBkColor ( ID_kontrolki, kolor_tła )

Funkcja ustawia kolor tła pojedynczej kontrolki. Zwraca 1 gdy sukces lub 0 gdy wystąpił błąd.

ID_kontrolki - numer identyfikacyjny (ID) kontrolki, domyślnie kontrolka bieżąca.

kolor_tła - kod koloru tła (RGB), patrz opis przy GUISetBkColor.


GUICtrlSetDefBkColor ( kolor_tła [, uchwyt] )

Funkcja ustawia kolor tła dla wszystkich następnie zdefiniowanych kontrolek. Zwraca 1 gdy sukces lub 0 gdy wystąpił błąd.

kolor_tła - kod koloru tła (RGB), patrz opis przy GUISetBkColor.

uchwyt - uchwyt okna do którego ma się odnosić ta funkcja (należy podać gdy mamy większą ilość utworzonych okien, a funkcja nie dotyczy okna bieżącego, w przeciwnym wypadku parametr można pominąć).

UWAGA: Funkcje działają tylko z kontrolkami: BUTTON, LABEL, CHECKBOX, GROUP, RADIO, EDIT, INPUT, LIST, LIST_VIEW, LIST_VIEW_ITEM, LIST_VIEW, LIST_VIEW_ITEM, GRAPHIC, PROGRESS, SLIDER i COMBO.

Przykład:

#include <GUIConstantsEx.au3>

GUICreate("Kolorowe kontrolki")

GUICtrlCreateLabel(" Kolorowa"&@LF&" etykietka", 165, 50)
GUICtrlSetBkColor(-1, 0x00ff00) 	;zielona
$button=GUICtrlCreateButton("KONIEC",140,250,100)
GUICtrlSetBkColor(-1, 0x0ff0000) 	;czerwony
GUICtrlSetDefBkColor(0x0ffff00) 	;dalej na zółto
GUICtrlCreateCheckbox("Opcja 1",50,120)
GUICtrlCreateCheckbox("Opcja 2",50,150)
GUICtrlCreateCheckbox("Opcja 3",50,180)
GUISetState()

Do
   $msg = GUIGetMsg()
Until ($msg = $GUI_EVENT_CLOSE Or $msg = $button)


Kolor napisów w kontrolce[edytuj]

GUICtrlSetColor ( ID_kontrolki, kolor_tekstu )

Funkcja ustawia kolor tła pojedynczej kontrolki. Zwraca 1 gdy sukces lub 0 gdy wystąpił błąd.

ID_kontrolki - numer identyfikacyjny (ID) kontrolki, domyślnie kontrolka bieżąca.

kolor_tekstu - kod koloru ttekstu (RGB), patrz opis przy GUISetBkColor.

GUICtrlSetDefBkColor ( kolor_tła [, uchwyt] )

Funkcja ustawia kolor tekstu dla wszystkich następnie zdefiniowanych kontrolek. Zwraca 1 gdy sukces lub 0 gdy wystąpił błąd.

kolor_tła - kod koloru tła (RGB), patrz opis przy GUISetBkColor.

uchwyt - uchwyt okna do którego ma się odnosić ta funkcja (należy podać gdy mamy większą ilość utworzonych okien, a funkcja nie dotyczy okna bieżącego, w przeciwnym wypadku parametr można pominąć).


UWAGA: Obie funkcje działają tylko z niektórymi kontrolkami: BUTTON, COMBO (tylko wybrana pozycja), EDIT, INPUT, LABEL, LIST, LIST_VIEW (z wyjątkiem nazw kolumn), TREE

Przykład:

#include <GUIConstantsEx.au3>

GUICreate("Kolorowe napisy")

GUICtrlCreateLabel(" Kolorowa"&@LF&" etykietka", 165, 50)
GUICtrlSetColor(-1, 0x00aa00) 	;zielona
$button=GUICtrlCreateButton("KONIEC",140,250,100)
GUICtrlSetColor(-1, 0x0ff0000) 	;czerwony
GUICtrlSetDefColor(0x0000ff)    ;dalej na niebiesko
;nie działa na nazwach kolumn
$listview = GUICtrlCreateListView("kolumna 1 | kolumna 2 | kolumna 3", 65, 100, 260, 100)
;dalej już działa
$item1 = GUICtrlCreateListViewItem("poz.11|poz.21|poz.23", $listview)
$item2 = GUICtrlCreateListViewItem("poz.21|poz.22|poz.23", $listview)
$item3 = GUICtrlCreateListViewItem("poz.31|poz.32|poz.33", $listview)

GUISetState()
Do
   $msg = GUIGetMsg()
Until ($msg = $GUI_EVENT_CLOSE Or $msg = $button)


Ustawienie wyglądu kursora po najechaniu na kontrolkę[edytuj]

GUICtrlSetCursor ( ID_kontrolki, ID_kursora )

Funkcja ustawia wygląd kursora myszki po najechaniu na kontrolkę. Zwraca 1 gdy sukces lub 0 gdy wystąpił błąd.

ID_kontrolki - numer identyfikacyjny (ID) kontrolki, domyślnie kontrolka bieżąca.

ID_kursora - numer identyfikacyjny (ID) kursora (patrz GUISetCursor).

Przykład:

#include <GUIConstantsEx.au3>

GUICreate("put cursor over label", 300, 100)
$buttom=GUICtrlCreateButton("Koniec", 100, 40,100)
GUICtrlSetCursor(-1, 0)    ;łapka

GUISetState()
Do
   $msg = GUIGetMsg()
Until ($msg = $GUI_EVENT_CLOSE Or $msg = $buttom)


Wprowadzanie danych do kontrolki[edytuj]

GUICtrlSetData ( ID_kontrolki, dane [, def] )

Funkcja wprowadza dane do kontrolki. Zwraca 1 gdy sukces, 0 gdy wystąpił błąd, -1 jeżeli dane są błędne.

ID_kontrolki - numer identyfikacyjny (ID) kontrolki, domyślnie kontrolka bieżąca.

dane - dane wprowadzane do kontrolki, typ danych wg poniższej tabelki.

def - wartość domyślna, dla EDIT i INPUT jeżeli nie jest stringiem pustym, to dane są dopisywane w miejscu kursora (a nie nadpisywane).

Kontrolka         | Typ danych
----------------------------------------------------------------
COMBO             | lista danych rozdzielonych separatorami,
LIST              | standardowo pionowa kreska (|),
LIST_VIEW         | można przedefiniować funkcją AutoItSetOption
LIST_VIEW_ITEM    | np.: Opt("GUIDataSeparatorChar","#")
----------------------------------------------------------------
PROGRESS          | postęp w procentach
----------------------------------------------------------------
SLIDER            | wartość
----------------------------------------------------------------
GROUP, LABEL      | zmiana tekstu w kontrolce
BUTTON, CHECKBOX  |
RADIO, EDIT       |
INPUT, TAB_ITEM   |
TREE_VIEW_ITEM    |
----------------------------------------------------------------
DATE              | wybrana data
MONTHCAL          | format daty "rrrr/mm/dd"
----------------------------------------------------------------
DUMMY             | wartość

Przykład:

#include <GUIConstantsEx.au3>

GUICreate("GUICtrlSetData:")
$edit=GUICtrlCreateEdit("", 50, 10)
$combo=GUICtrlCreateCombo("Jeden",50,200,-1,-1,0x400)
GUICtrlSetData($combo,"2|3|4")
GUISetState()
GUICtrlSetData($edit, "Ala ma Asa.")
Sleep (2000)
GUICtrlSetData($edit, "Ola ")       ;nadpisanie
Sleep (1000)
GUICtrlSetData($edit, "ma ", "x")   ;dopisanie
Sleep (1000)
GUICtrlSetData($edit, "kota.", "x") ;dopisanie
Sleep (2000)
GUICtrlSetData($combo,"|Jeden|Dwa|Trzy|Cztery","Trzy")
Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE


Ustawienie czcionki dla kontrolki[edytuj]

GUICtrlSetFont ( ID_kontrolki, wielkość_fontu [, waga_fontu [, atrybut [, nazwa_fontu [, jakość_fontu]]]] )

Funkcja ustawia czcionkę dla pojedynczej kontrolki. Zwraca 1 gdy sukces lub 0 gdy wystąpił błąd.

ID_kontrolki - numer identyfikacyjny (ID) kontrolki, domyślnie kontrolka bieżąca.

wielkość_fontu - wielkość fontów (domyślnie 8,5; typowe rozmiary to: 6 8 9 10 11 12 14 16 18 20 22 24 26 28 36 48 72)

Pozostałe opcjonalnie:

waga_fontu - tzw. waga fontu, czyli grubość linii tworzących fonty, wartość od 0 do 1000 (domyślnie 400, mniejsze wartości to fonty pocienione, większe pogrubione)

atrybut - atrybuty fontu (2 - pochylony (italic), 4 - podkreślony, 8 - przekreślony, domyślnie 1 - font zwykły. Wartości atrybutów można sumować np. 6 (2+4) - podkreślony italic)

"nazwa_fontu" - nazwa użytych fontów, zgodna z nazwami systemowymi np.:Arial, Comic Sans MS, Courier New, Lucida Console, Microsoft Sans Serif, System, Tahoma, Times New Roman, WingDings itd. (domyślnie - domyślny font systemowy).

jakość_fontu - domyślnie 2 (PROOF_QUALITY)

Przykład:

#include <GUIConstantsEx.au3>

GUICreate("Test fontów w oknie GUI")

$font = "Comic Sans MS"

GUICtrlCreateLabel("Pismo pochylone.", 10, 20,200)
GUICtrlSetFont(-1,16, 400, 2)                 ;zmiana czcionki

GUICtrlCreateLabel("Pismo normalne.", 10, 60) ;znowu czcionka domyślna

GUICtrlCreateLabel("Wszystko naraz.", 10, 130,300,50)
GUICtrlSetFont(-1, 20, 1000, 14, $font)       ;zmiana czcionki

GUISetState()
Do
Until GUIGetMsg()=$GUI_EVENT_CLOSE


Rysowanie w okienku graficznym[edytuj]

GUICtrlSetGraphic ( ID_kontrolki, typ [, par1 [, ... par6]] )

Funkcja umożliwia wykonywanie operacji graficznych we wnętrzu okienka graficznego utworzonego przez GUICtrlCreateGraphic. Zwraca 1 gdy sukces, 0 gdy wystąpił błąd, -1 jeżeli dane są błędne.

ID_kontrolki - numer identyfikacyjny (ID) kontrolki, domyślnie kontrolka bieżąca.

typ - typ operacji graficznej (wg poniższej tabeli)

par1, ... par6 - opcjonalne parametry, ich ilość i rodzaj zależy od typu operacji graficznej (typ)

Typ              | Parametry      | Rezultat 
---------------------------------------------------------------------------------------
$GUI_GR_COLOR    | Color[,BkColor]| ustawienie kolorów dla następnych rysunków
                 |                | jeżeli BkColor=$GUI_GR_NOBKCOLOR rysunek
                 |                | nie będzie wypełniony (domyślnie)
                 |                | domyślnym kolorem linii jest czarny
---------------------------------------------------------------------------------------
$GUI_GR_MOVE     | x,y            | przesunięcie bieżącej pozycji, bez rysowania
---------------------------------------------------------------------------------------
$GUI_GR_DOT      | x,y            | rysowanie punktu, nie przesuwa bieżących pozycji
---------------------------------------------------------------------------------------
$GUI_GR_PIXEL    | x,y            | rysowanie piksela, nie przesuwa bieżących pozycji
--------------------------------------------------------------------------------------
$GUI_GR_LINE     | x,y            | rysowanie linii od bieżącej pozycji do poz. x,y
---------------------------------------------------------------------------------------
$GUI_GR_BEZIER   | x,y,x1,x2,y1,y2| rysowanie krzywej Beziera z 2 punktami kontrolnymi
---------------------------------------------------------------------------------------
$GUI_GR_RECT     | x,y,w,h        | rysowanie prostokąta, x,y - lewy górny narożnik,
                 |                | w - szerokość, h - wysokość, w=h - kwadrat
---------------------------------------------------------------------------------------
$GUI_GR_ELLIPSE  | x,y,w,h        | rysowanie elipsy, x,y - lewy górny narożnik 
                 |                | prostokąta w który wpisuje się elipsa,
                 |                | w - oś pozioma, h - oś pionowa, w=h - koło
---------------------------------------------------------------------------------------
$GUI_GR_PIE      | x,y,r,sa,wa    | wycinek koła, x,y - środek koła, r - promień koła
                 |                | sa - kąt początkowy, wa - kąt wycinka (w stopniach)
---------------------------------------------------------------------------------------
$GUI_GR_CLOSE    |                | zamknięcie operacji rysunkowej, należy dodać na 
                 |                | zakończenie $GUI_GR_LINE i $GUI_GR_BEZIER
---------------------------------------------------------------------------------------
$GUI_GR_REFRESH  |                | wymuszone odświeżenie po aktualizacji 
                 |                | dynamicznej grafiki
---------------------------------------------------------------------------------------
$GUI_GR_HINT     |                | wyświetlanie punktów kontrolnych i punktu 
                 |                | początkowego krzywej Beziera
---------------------------------------------------------------------------------------
$GUI_GR_PENSIZE  | n              | grubość pędzla (w pikselach),
                 |                | zadziała po zdefiniowaniu $GUI_GR_COLOR
---------------------------------------------------------------------------------------
$GUI_GR_NOBKCOLOR|                | rysunek bez wypełnienia, tylko linie

Przykład:

#include <GUIConstantsEx.au3>

GUICreate("Rysowanie:", 400, 400)   ;utworzenie okna głównego

GUICtrlCreateGraphic(0,0, 400, 400) ;okienko graficzne
GUICtrlSetGraphic(-1, $GUI_GR_COLOR, 0x000000, 0xffffff)
GUICtrlSetGraphic(-1, $GUI_GR_RECT, 100, 30, 200, 170) ;prostokąt
GUICtrlSetGraphic(-1, $GUI_GR_COLOR, 0xff0000, 0x88ff88)
GUICtrlSetGraphic(-1, $GUI_GR_ELLIPSE, 0, 0, 160, 40)  ;elipsa
GUICtrlSetGraphic(-1, $GUI_GR_MOVE, 10,80) ;przesunięcie punktu startowego
GUICtrlSetGraphic(-1, $GUI_GR_LINE, 200,150)
GUICtrlSetGraphic(-1, $GUI_GR_LINE, 300,10)
GUICtrlSetGraphic(-1, $GUI_GR_CLOSE)       ;zamknięcie rysowania linii
GUICtrlSetGraphic(-1, $GUI_GR_MOVE, 0,0)

GUICtrlSetGraphic(-1, $GUI_GR_PENSIZE, 10)
GUICtrlSetGraphic(-1, $GUI_GR_COLOR, 0xff00ff)
GUICtrlSetGraphic(-1, $GUI_GR_LINE, 400,400)
GUICtrlSetGraphic(-1, $GUI_GR_PENSIZE,0)
GUICtrlSetGraphic(-1, $GUI_GR_COLOR, 0x000000)
GUICtrlSetGraphic(-1, $GUI_GR_PIE, 250,300,90,-10,280)    ;wycinek koła
GUICtrlSetGraphic(-1, $GUI_GR_COLOR, 0, $GUI_GR_NOBKCOLOR)   ;bez tła
GUICtrlSetGraphic(-1, $GUI_GR_MOVE, 120, 220)
;krzywe Beziera
GUICtrlSetGraphic(-1, $GUI_GR_BEZIER, 120, 300, 200, 220, 200, 300)
GUICtrlSetGraphic(-1, $GUI_GR_HINT)    ;wyswietlenie punktów kontrolnych
GUICtrlSetGraphic(-1, $GUI_GR_BEZIER+$GUI_GR_CLOSE,100,240,40,300,40,220)

GUISetState()
Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE


Wstawienie do kontrolki bitmapy lub ikony[edytuj]

GUICtrlSetImage ( ID_kontrolki, nazwa_pliku [, ID_ikony [, typ_ikony]] )

Funkcja wstawia do kontrolki ikonę lub bitmapę. Zwraca 1 gdy sukces lub 0 gdy wystąpił błąd.

ID_kontrolki - numer identyfikacyjny (ID) kontrolki, domyślnie kontrolka bieżąca.

nazwa_pliku - nazwa pliku ikony lub bitmapy

Pozostałe opcjonalnie:

ID_ikony - numer ikony w pliku ikon (jeżeli plik zawiera bibliotekę ikon), domyślnie -1.

typ_ikony - wielkość ikony: 0 - mała, 1 - normalna (domyślnie), pozostałe tylko dla TREE_VIEV_ITEM: 2 - na pozycji wybranej, 4 - na pozycji nie wybranej

Przykład:

#include <GUIConstantsEx.au3>
#include <ButtonConstants.au3>

GUICreate("GUI obrazkowy:")

GUICtrlCreateButton("", 140, 280, 100, 50, $BS_ICON)
GUICtrlSetImage(-1, "shell32.dll", 22)

GUICtrlCreateButton("", 140, 340, 100, 50, $BS_BITMAP)
GUICtrlSetImage(-1, "C:\WINDOWS\Indiański pled.bmp")

GUICtrlCreateCheckbox("", 10, 200, 120, 40, $BS_ICON)
GUICtrlSetImage(-1, "shell32.dll", 23)
GUICtrlCreateCheckbox("", 150, 200, 120, 40, $BS_ICON)
GUICtrlSetImage(-1, "shell32.dll", 24)
GUICtrlCreateCheckbox("", 300, 200, 120, 40, $BS_ICON)
GUICtrlSetImage(-1, "shell32.dll", 25)

GUICtrlCreateRadio("", 20, 280, 120, 20, $BS_ICON)
GUICtrlSetImage(-1, "shell32.dll", 26)
GUICtrlCreateRadio("", 20, 320, 120, 20, $BS_ICON)
GUICtrlSetState(-1,  $GUI_CHECKED)
GUICtrlSetImage(-1, "shell32.dll", 27)

$treeOne=GUICtrlCreateTreeView(270, 30, 120, 150, $BS_ICON)
$treeItem1=GUICtrlCreateTreeViewItem("Drzewo 1", $treeOne)
GUICtrlSetImage(-1, "shell32.dll", 33)
$treeItem12=GUICtrlCreateTreeViewItem("Poz.2", $treeItem1)
GUICtrlSetImage(-1, "shell32.dll", 34)
$treeItem121=GUICtrlCreateTreeViewItem("Poz.21", $treeItem12)
GUICtrlSetImage(-1, "shell32.dll", 35)
$treeItem122=GUICtrlCreateTreeViewItem("Poz.22", $treeItem12)
GUICtrlSetImage(-1, "shell32.dll", 36)
$treeItem2=GUICtrlCreateTreeViewItem("Drzewo 2", $treeOne)
GUICtrlSetImage(-1, "shell32.dll", 37)
$treeItem21=GUICtrlCreateTreeViewItem("Poz.21", $treeItem2)
GUICtrlSetImage(-1, "shell32.dll", 38)


GUICtrlCreateTab(10, 10, 200, 100, $BS_ICON)
GUICtrlCreateTabItem("Zakładka 1")
GUICtrlSetImage(-1, "shell32.dll", 39)

GUISetState()
Do
   $msg = GUIGetMsg()
Until $msg = $GUI_EVENT_CLOSE


Ustalenie maksymalnej i minimalnej wielkości danych wprowadzanych do kontrolki[edytuj]

GUICtrlSetLimit ( ID_kontrolki, max [, min] )

Funkcja ustala maksymalną i minimalną wielkość danych wprowadzanych do kontrolki. Sposób ograniczenia zależy od typu kontrolki. Zwraca 1 gdy sukces lub 0 gdy wystąpił błąd.

ID_kontrolki - numer ID kontrolki, domyślnie -1.

max - maksymalna wielkość danych.

min - minimalna wielkość danych (opcjonalnie).

Kontrolka  | Opis
------------------------------------------------------------
LIST       | max - maksymalny zakres przewijania w poziomie
           |------------------------------------------------
           | min - nie działa
------------------------------------------------------------
INPUT      | max - maksymalna ilość wprowadzonych znaków
EDIT       |------------------------------------------------
           | min - nie działa
------------------------------------------------------------
SLIDER     | max - maksymalna wartość liczbowa 
UP_DOWN    |------------------------------------------------
           | min - minimalna wartość liczbowa 

Przykład:

#include <GUIConstantsEx.au3>

GUICreate("Limit:")

GUICtrlCreateInput("", 20, 20)
GUICtrlSetLimit(-1, 13)   ;max 13 znaków

GUICtrlCreateEdit("", 20, 50)
GUICtrlSetLimit(-1, 30)

$slider=GUICtrlCreateSlider(20, 230, 230, 40)
GUICtrlSetLimit(-1, 150,-50) ;zakres od -50 do 150

GUICtrlCreateInput("0", 20, 300, 100, 25)
GUICtrlCreateUpdown(-1)
GUICtrlSetLimit(-1, 150,-50)

GUISetState()
Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE
MsgBox(0,"SLIDER:",GUICtrlRead($slider))


Ustalenie jaka funkcja użytkownika ma być wywołana, jeżeli zostanie kliknięta kontrolka[edytuj]

GUICtrlSetOnEvent ( ID_kontrolki, "nazwa_funkcji" )

Zwraca 1 gdy sukces lub 0 gdy wystąpił błąd.

ID_kontrolki - numer identyfikacyjny (ID) kontrolki, domyślnie kontrolka bieżąca.

"nazwa_funkcji" - nazwa wywoływanej funkcji, string pusty "" oznacza anulowanie przypisania danej funkcji.

UWAGA: Aby funkcja była aktywna należy zadeklarować Opt("GUIOnEventMode",1) (domyślnie jest Opt("GUIOnEventMode",0)), powoduje to jednocześnie wyłączenie funkcji GUIGetMsg.

Zadeklarowanie Opt("GUIOnEventMode",0) przywraca stan pierwotny.

Przykład:

#include <GUIConstantsEx.au3>
Opt("GUIOnEventMode",1)

GUICreate("Przechwycenie kontrolki:", 400, 280,-1,-1,0)
$button=GUICtrlCreateButton("Koniec",150,200,100,20)
GUICtrlSetOnEvent($button,"end")

$label=GUICtrlCreateLabel("Kliknij tutaj!",-1,30)
GUICtrlSetOnEvent($label,"label")

GUISetState()
Do
Until False

;własna funkcje obsługi kontrolek
Func ping_1()
   Beep(400,1000)
EndFunc

Func ping_2()
   Beep(600,1000)
EndFunc

Func ping_3()
   Beep(800,1000)
EndFunc

Func label()
   $radio1 = GUICtrlCreateRadio("Ping 1", 20, 60, 120, 20)
   $radio2 = GUICtrlCreateRadio("Ping 2", 20, 90, 120, 20)
   $radio3 = GUICtrlCreateRadio("Ping 3", 20, 120, 120, 20)
   GUICtrlSetOnEvent($radio1,"ping_1")
   GUICtrlSetOnEvent($radio2,"ping_2")
   GUICtrlSetOnEvent($radio3,"ping_3")
   GUICtrlCreateLabel("Maszyna, która robi Ping",60,20,260,30)
   GUICtrlSetFont(-1,16, 400, 2)
EndFunc

Func end()
   ping_1()
   ping_2()
   ping_3()
   Exit
EndFunc


Ustawienie położenia kontrolki w oknie GUI[edytuj]

GUICtrlSetPos ( ID_kontrolki, x, y [, szerokość [, wysokość ]] )

Funkcja umożliwia zmianę położenia kontrolki w oknie GUI i opcjonalnie zmianę jej rozmiarów. Zwraca 1 gdy sukces lub 0 gdy wystąpił błąd.

ID_kontrolki - numer identyfikacyjny (ID) kontrolki, domyślnie kontrolka bieżąca.

x i y - położenie wewnątrz okna GUI (w pikselach).

Pozostałe parametry opcjonalne:

szerokość i wysokość - wielkość pola kontrolki (w pikselach).

Przykład:

#include <GUIConstantsEx.au3>

GUICreate("Uciekający przycisk:",400,400)
$hButton = GUICtrlCreateButton(" Naciśnij przycisk! ", 50, 50)

GUISetState()
Do
   $aTab = GUIGetCursorInfo()            ;dane o kursorze myszki
   If $aTab[4]=$button Then            ;jeżeli kursor jest nad przyciskiem
      $x = Random(0,300,1)              ;liczba losowa
      $y = Random(0,350,1)
      $h = Random(20,50)
      GUICtrlSetPos($hButton, $x, $y,-1,$h) ;przesunięcie i zmiana rozmiaru
   EndIf
Until GUIGetMsg() = $GUI_EVENT_CLOSE


Ustalenie sposobu reagowania kontrolek na zmianę wielkości okna GUI[edytuj]

GUICtrlSetResizing ( ID_kontrolki, opcja )

Funkcja umożliwia zmianę sposobu reagowania kontrolki na zmianę rozmiaru okna GUI. Zwraca 1 gdy sukces lub 0 gdy wystąpił błąd.

ID_kontrolki - numer identyfikacyjny (ID) kontrolki, domyślnie kontrolka bieżąca.

opcja - parametr określający sposób reagowania kontrolki, domyślną wartość tego parametru można zmienić za pomocą Opt("GUIResizeMode", opcja) - AutoIt/Dyrektywy i funkcje konfiguracyjne translatora.

Stała             |  HEX  | Opis
----------------------------------------------------------------------------------
$GUI_DOCKAUTO     |     1 | automatyczne dopasowanie do nowej wielkości okna
$GUI_DOCKLEFT     |     2 | zaczepiona do lewej strony
$GUI_DOCKRIGHT    |     4 | zaczepiona do prawej strony
$GUI_DOCKHCENTER  |     8 | centrowana w poziomie
----------------------------------------------------------------------------------
$GUI_DOCKTOP      |  0x20 | zaczepiona od góry
$GUI_DOCKBOTTOM   |  0x40 | zaczepiona od dołu
$GUI_DOCKVCENTER  |  0x80 | centrowana w pionie
----------------------------------------------------------------------------------
$GUI_DOCKWIDTH    | 0x100 | nie zmienia szerokości
$GUI_DOCKHEIGHT   | 0x200 | nie zmienia wysokości
----------------------------------------------------------------------------------
$GUI_DOCKSIZE     | 0x300 | (0x100+0x200) nie zmienia rozmiarów
---------------------------------------------------------------------------------- 
$GUI_DOCKMENUBAR  | 0x220 | (0x200+0x20) nie zmienia wysokości, zaczepiona od góry
----------------------------------------------------------------------------------
$GUI_DOCKSTATEBAR | 0x240 | (0x200+0x40) nie zmienia wysokości, zaczepiona od dołu
----------------------------------------------------------------------------------
$GUI_DOCKALL      | 0x322 | (0x200+0x100+0x20+2) nie zmienia rozmiarów i położenia
----------------------------------------------------------------------------------
$GUI_DOCKBORDERS  |  0x66 | (0x40+0x20+4+2) zmienia wymiary tak jak okno

UWAGA: Funkcja działa tylko w przypadku utworzenia okna GUI ze stylem umożliwiającym zmianę jego rozmiarów.

Przykład:

#include <GUIConstantsEx.au3>

GUICreate("Rozciąganie i sciskanie:", 190, 114, -1, -1, 0x70000)
GUICtrlCreateLabel("Etykietka LABEL", 8, 7)
GUICtrlSetResizing(-1, $GUI_DOCKLEFT + $GUI_DOCKTOP)

GUICtrlCreateInput("Zawartosć początkowa", 10, 33, 175, 20)
GUICtrlSetResizing(-1, $GUI_DOCKBOTTOM + $GUI_DOCKHEIGHT)

GUICtrlCreateButton("OK", 10, 60, 75, 24)
GUICtrlSetResizing(-1, $GUI_DOCKBOTTOM + $GUI_DOCKSIZE + $GUI_DOCKHCENTER)

GUICtrlCreateButton("Anuluj", 100, 60, 75, 24)
GUICtrlSetResizing(-1, $GUI_DOCKBOTTOM + $GUI_DOCKSIZE + $GUI_DOCKHCENTER)

GUISetState()
Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE


Ustawienie stylu kontrolki[edytuj]

GUICtrlSetStyle ( ID_kontrolki, style [, exStyle] )

Funkcja umożliwia zmianę stylu kontrolki (zmiana parametrów style i exstyle). Zwraca 1 gdy sukces lub 0 gdy wystąpił błąd.

ID_kontrolki - numer identyfikacyjny (ID) kontrolki, domyślnie kontrolka bieżąca.

style i exstyle - parametry określające styl kontrolki. Opisane przy funkcjach tworzących kontrolki.

Przykład:

#include <GUIConstantsEx.au3>
#include <StaticConstants.au3>

GUICreate("My GUI style")
GUICtrlCreateLabel("To jest etykietka"&@LF&"testowa", 50, 30, 200, 50)
GUISetState()
GUICtrlSetStyle(-1, $SS_RIGHT)   ;wyrównanie do prawej
Sleep(3000)
GUICtrlSetStyle(-1, $SS_CENTER)  ;wyrównanie do lewej
Sleep(3000)
GUICtrlSetStyle(-1, $SS_LEFT)    ;centrowanie
Sleep(3000)


Tworzenie etykietki ukazującej się po najechaniu na kontrolkę[edytuj]

GUICtrlSetTip ( ID_kontrolki, "tekst" [, "tytuł" [, ikona [, opcja]]]]] )

Funkcja zwraca 1 gdy sukces lub 0 gdy wystąpił błąd.

ID_kontrolki - numer identyfikacyjny (ID) kontrolki, domyślnie kontrolka bieżąca.

"tekst" - tekst na etykietce

"tytuł" - tytuł etykietki (domyślnie brak tytułu)

ikona - rodzaj ikony na etykietce, 0 - bez ikony (domyślne), 1 - informacja, 2 - ostrzeżenie, 3 - błąd

opcja - 1 - dymek z ogonkiem na boku , 3 - dymek z ogonkiem na środku (domyślnie prostokąt)

Przykład:

#include <GUIConstantsEx.au3>

GUICreate("GUICtrlSetTip:")
GUICtrlCreateLabel("Tekst kontrolny", 10, 20)
GUICtrlSetTip(-1, "To jest etykietka")
GUICtrlCreateInput("", 20, 60)
GUICtrlSetTip(-1, "To jest pole wprowadzania","Opis kontrolki")
GUICtrlCreateEdit("Ala ma Asa.", 20, 150,300,100)
GUICtrlSetTip(-1, "To jest edytor"," ",1,1)
GUICtrlCreateSlider(20, 270, 230, 40)
GUICtrlSetTip(-1, "To jest suwak"," ",2,3)

GUISetState()
Do
Until GUIGetMsg() = $GUI_EVENT_CLOSE


Ćwiczenia[edytuj]

1. W oparciu o funkcję GUICtrlCreateInput napisać funkcję umożliwiającą wprowadzanie wyłącznie liczb dziesiętnych. Liczby mogą być dodatnie lub ujemne, całkowite lub z kropką dziesiętną. Stworzoną funkcję użyj w prostym skrypcie demonstracyjnym.


2. Korzystając z kontrolek GUI napisać skrypt wyświetlający na ekranie zegar analogowo cyfrowy. Aby zajmować jak najmniej miejsca na ekranie zegar powinien mieć możliwość wyświetlania okna bez belki i ramki. W tym stanie zegar powinien mieć atrybut "zawsze na wierzchu". Należy także zapewnić możliwość przemieszczanie zegara w wygodne dla użytkownika miejsce ekranu.


Przykładowe rozwiązania: AutoIt/Ćwiczenia dla zaawansowanych - przykładowe rozwiązania