AutoIt/GUI
Co to jest GUI?
edytujGUI - 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?
edytujOmó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
edytujKontrolki 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
edytujWiemy 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
edytujStwó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
edytujPonieważ 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
edytujW systemie Windows istnieje wiele różnych typów okien. Okna overlapped to standardowe okna z ramką i napisem tytułowym. Okna typu child to okna potomne, wyświetlane w obszarze roboczym swojego okna rodzica. Kiedy przesuwasz po ekranie okno rodzica, to razem z nim przesuwają się wszystkie jego okna-dzieci. Okna typu popup to również okna potomne, wyświetlane jednak niezależnie od położenia i rozmiarów okna rodzica. Okna potomne znajdują się zawsze nad swoim oknem-rodzicem (nie mogą być przez nie zasłonięte). Również obiekty sterujące typu: przyciski, listbox'y, paski przewijania i inne opisane niżej obiekty są oknami.
Tworzenie okna GUI
edytujGUICreate ( "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
edytujGUIDelete ( [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
edytujGUIRegisterMsg ( 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
edytujGUIStartGroup ( [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
edytujGUISwitch ( 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
edytujGUIGetCursorInfo ( [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
edytujGUIGetMsg ( [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
edytujGUIGetStyle ( [ 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
edytujGUISetAccelerators ( 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
edytujGUISetBkColor ( 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
edytujPrzy 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
edytujGUISetCoord ( 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
edytujGUISetCursor ( [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
edytujGUISetFont (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)
edytujGUISetHelp ( "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ń
edytujGUISetIcon ( "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
edytujGUISetOnEvent ( 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.)
edytujGUISetState ( [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
edytujGUISetStyle ( 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
edytujUsunięcie kontrolki
edytujGUICtrlDelete ( 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
edytujGUICtrlRead ( 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
edytujGUICtrlSendMsg ( 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
edytujGUICtrlSendToDummy ( 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)
edytujGUICtrlCreateAvi ( "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)
edytujGUICtrlCreateButton ( "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)
edytujGUICtrlCreateCheckbox ( "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)
edytujGUICtrlCreateCombo ( "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)
edytujGUICtrlCreateContextMenu ( [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)
edytujGUICtrlCreateDate ( "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)
edytujGUICtrlCreateDummy ( )
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)
edytujGUICtrlCreateEdit ( "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)
edytujGUICtrlCreateGraphic ( 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)
edytujGUICtrlCreateGroup ( "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)
edytujGUICtrlCreateIcon ( "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)
edytujGUICtrlCreateInput ( "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)
edytujGUICtrlCreateLabel ( "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)
edytujGUICtrlCreateList ( "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)
edytujGUICtrlCreateListView ( "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)
edytujGUICtrlCreateListViewItem ( "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)
edytujGUICtrlCreateMenu ( "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)
edytujGUICtrlCreateMenuItem ( "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)
edytujGUICtrlCreateMonthCal ( "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)
edytujGUICtrlCreatePic ( "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)
edytujGUICtrlCreateProgress ( 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)
edytujGUICtrlCreateRadio ( "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)
edytujGUICtrlCreateSlider ( 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)
edytujGUICtrlCreateTab ( 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)
edytujGUICtrlCreateTabItem ( "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)
edytujGUICtrlCreateTreeView ( 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)
edytujGUICtrlCreateTreeViewItem ( "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)
edytujGUICtrlCreateUpdown ( 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
edytujGUICtrlGetHandle ( [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
edytujGUICtrlGetState ( [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
edytujGUICtrlSetState ( 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
edytujGUICtrlSetBkColor ( 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
edytujGUICtrlSetColor ( 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.
GUICtrlSetDefColor ( kolor_tekstu [, uchwyt] )
Funkcja ustawia kolor tekstu dla wszystkich następnie zdefiniowanych kontrolek. Zwraca 1 gdy sukces lub 0 gdy wystąpił błąd.
kolor_tekstu - kod koloru tekstu (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ę
edytujGUICtrlSetCursor ( 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
edytujGUICtrlSetData ( 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
edytujGUICtrlSetFont ( 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
edytujGUICtrlSetGraphic ( 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
edytujGUICtrlSetImage ( 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
edytujGUICtrlSetLimit ( 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
edytujGUICtrlSetOnEvent ( 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
edytujGUICtrlSetPos ( 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
edytujGUICtrlSetResizing ( 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
edytujGUICtrlSetStyle ( 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ę
edytujGUICtrlSetTip ( 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
edytuj1. 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