+- BorderGame (https://www.bordergame.it)
+-- Forum: Programmazione (/Forum-Programmazione--158)
+--- Forum: Programmazione (/Forum-Programmazione)
+---- Forum: Autoit (/Forum-Autoit)
+----- Forum: Guide autoit (/Forum-Guide-autoit)
+----- Discussione: AutoIT - GUIDA GENERALE (/Thread-AutoIT-GUIDA-GENERALE)
AutoIT - GUIDA GENERALE - Lawliet - 05-03-2012 11:09 PM
Ecoo la guida di AutoIT
Per cominciare a programmare è necessario avere gli strumenti giusti:
----------------------Installazione----
Scaricate da qui
AutoIt Full Installation
Questo pacchetto installerà nel vostro sistema:
-I file essenziali del programma AutoIt3
-L'utility Aut2Exe per convertire i vostri script AutoIt in Exe compilati
-L'addon AutoItX per gestire i controlli sulle COM e sulle DLL
-Una versione ridotta dell'editor SciTE con il riconoscimento automatico
della sintassi di AutoIt
Installate l'eseguibile (durante l'installazione, scegliete di EDITARE i
file .au3 con il doppio click)
Ora andate su start / Tutti i programmi / AutoIt v3 / SciTE Script Editor
Ok, questo è SciTE, salutate SciTE bambini [ciaoooo sciiite]
Cliccate su File / New, si aprirà un foglio virtuale. Dovete scrivere il
vostro script qui.
Il file va salvato con estensione .AU3
Per eseguire il codice scritto dovete salvare in un file.au3 e poi
andare in Tools / Go (in alternativa premete soltanto F5)
----------------------Let's-Code-------
----Hello-World--
Cominciamo con un Hello World! Si tratta semplicemente di creare un
programma che si limiti a stampare a schermo la scritta Hello World
Digitate la seguente riga: (non copiatela e incollatela)
*CODICE*
Msgbox (0, "Io sono il titolo", "Hello World!")
Avrete tutti notato (tranne quei somari che hanno fatto copia-incolla
Smile ) che appena aperta la parentesi SciTE vi ha mostrato una semplice
descrizione della funzione e i possibili parametri che vanno passati
I parametri, separati da virgole dentro alle parentesi tonde, sono tutti
obbligatori tranne quelli compresi tra parentesi quadre; quelli sono
opzionali.
Ora prendiamo la riga che abbiamo scritto
*CODICE*
Msgbox (0, "Io sono il titolo", "Hello World!")
Abbiamo passato come primo parametro, flag 0; questo indica che non ci
saranno icone o tasti speciali nella nostra msgbox
Come secondo e terzo parametro, title e text abbiamo passato una stringa
alfanumerica. Le stringhe sono comprese tra gli apici, questi = > " "
Il quarto parametro opzionale indica il timeout ovvero il tempo che deve
passare prima che la finestra si chiuda. Noi vogliamo che il nostro
Hello World resti attivo fino a quando l'utente non prema [ OK ] quindi
dobbiamo lasciare vuoto questo campo.
----Variabili-e-Macro--
Le variabili in AutoIt sono facilmente riconoscibili: una variabile
comincia sempre con il simbolo del dollaro, questo = > $
Le variabili possono essere viste come delle scatole contenenti un valore.
Le variabili possono modificare il valore che contengono durante
l'esecuzione del programma.
Per assegnare un valore a una variabile è sufficiente scrivere:
*CODICE*
$variabile = 6
$variabile = "stringa"
Nel primo caso la $variabile assumerà il valore 6, nel secondo caso
assumerà valore "stringa"
Provate a scrivere
*CODICE*
$variabile = 6
Msgbox (0, "", $variabile)
e cambiate il valore di $variabile. Sperimentate! Very Happy
Ogni funzione ritorna sempre un valore.
Come esempio prenderemo StringUpper che ritorna la stringa inserita con
i caratteri in maiuscolo.
*CODICE*
$string_upped = StringUpper ( "m2o: musica allo stato puro" )
Msgbox (0, "Fraev sta ascoltando:", $string_uppde)
Stiamo assegnando il valore ritornato da StringUpper alla variabile
$string_upped.
Volendo possiamo perfino saltare un passaggio è scrivere direttamente
*CODICE*
Msgbox (0, "Fraev sta ascoltando:", StringUpper ( "m2o: musica allo
stato puro" ))
Eh già, anche in AutoIt è possibile concatenare le funzioni
Le macro invece cominciano sempre con la chiocciola (questa = > @) e, al
contrario delle variabili, il loro valore non può essere modificato
dallo scripter.
Le macro possono rappresentare valori costanti o valori che possono
variare con il tempo. Un esempio di Macro è dato da @ComputerName.
Provate a scrivere
*CODICE*
Msgbox (0, "Il nome del computer", @ComputerName)
Una variabile può assumere anche il valore di una macro
@YDAY indica il giorno dell'anno da 1 a 365/366
*CODICE*
$variabile = @YDAY
Msgbox (0, "Giorno dell'anno", $variabile)
Gli argomenti trattati sono davvero basilari... ma bisogna cominciare
dalle cose semplici, no?
----Array--
Fino ad adesso abbiamo visto le variabili come delle scatole contenenti
dei valori.
Gli array sono un insieme di scatole
Gli array in pratica sono dei gruppi di variabili ordinati.
Per popolare gli array (-> attribuire valori alle "scatole" degli array)
si può scrivere:
*CODICE*
dim $array[5] = [8, 4, 5, 9, 1]
Per lavorare con gli array ci sono le funzioni e _Array*
----Operazioni-con-le-stringhe--
In AutoIt le stringhe possono essere unite tra loro usando il simbolo
della E commerciale, questo = > &
Quindi se vorrò unire una variabile a una linea di testo sarà
sufficiente scrivere
*CODICE*
$var= "io so"
$var2 = "no"
$var3 = "il"
$var4 = "na"
Msgbox (0, "Questo esempio fa schifo", $var & $var2 & " " & $var3 & " "
& $var2 & $var2 & " " & $var4 & $var2)
Provate a indovinare cosa c'è scritto... senza eseguire il codice
Per andare a capo esiste la macro @CRLF
Anche le macro possono essere unite a una variabile o una stringa mediante &
*CODICE*
Msgbox (0, "Io non ho paura", "Io non ho paura di niente" & @CRLF &
@CRLF & "..." & @CRLF & @CRLF & "tranne di
AutoIt")
lol, scusate, non so come faccio a inventarmi degli esempi del genere...
mi sembra di essere persino sobrio
: D
Sulle stringhe è inoltre possibile utilizzare delle funzioni per
modificarle.
Le funzioni per modificare le stringhe cominciano con String* e con _String*
Le funzioni sono di una semplicità unica. Inoltre gli esempi correlati
spiegano molto bene come scrivere il codice.
Leggete bene l'help ufficiale.
Mi soffermerò un attimo solo su StringSplit per spiegare come usare le
funzioni.
*CODICE*
$array = StringSplit ("Marta è bellissima", " ")
Questa funzione prende una stringa e. dato un certo delimitatore.
ritorna un array dove $array[0] è uguale al numero
di valori presenti nell'array (senza contare zero) e $array[1] e gli
altri sono uguali alle stringhe delimitate dal
delimitatore
Nel nostro caso il delimitatore è " " (lo spazio) quindi
$array[0]=3 $array[1]="Marta", $array[2]="è" e $array[3]="bellissima"
Questo è anche un buon metodo per popolare gli array
----Operazioni-con-i-files--
Come possiamo effettuare le più comuni operazioni sui files in AutoIt?
Le funzioni riguardanti i file iniziano con File* e con _File*
1. Aprire un file:
Per aprire un file possiamo usare il comando
*CODICE*
$handle_del_file = FileOpen ("nomefile.txt", $mode)
Da una funzione FileOpen ritorna sempre l'handle di un file che potrà
essere usato in altre funzioni (FileRead per esempio.)
Il $mode specifica come stiamo aprendo quel file.
Se $mode è maggiore di 0 il file è aperto in Read mode e l'handle potrà
essere usato in una funzione FileRead
Se $mode è uguale a 1 il file è aperto anche in Write Mode e l'handle
potrà essere usato in una funzione FileWrite dove il testo verrà
aggiunto alla fine del file
Se $mode è uguale a 2 il file è aperto anche in Write Mode e l'handle
potrà essere usato in una funzione FileWrite dove il testo sovrascriverà
il testo esistente
2. Scrivere in un file:
Per scrivere all'interno di un File possiamo usare FileWrite o
FileWriteLine.
FileWriteLine è uguale a FileWrite ma aggiunge un @CRLF alla fine della
stringa facendo andare a capo il puntatore
FileWrite(Line) può essere usato così
*CODICE*
FileWrite ($handle_del_file, "Wow sto scrivendo dentro nomefile.txt")
Oppure
*CODICE*
FileWrite ("nomefile.txt", "Wow sto scrivendo dentro nomefile.txt")
L'unica differenza è che usando l'handle del file è possibile tenere
aperto il file.
3. Leggere un file:
Per leggere un file basta scrivere
*CODICE*
$testo = FileRead ($handle_del_file, 100)
;oppure
*CODICE*
$testo = FileRead ("nomefile.txt", 100)
il secondo parametro indica il numero di caratteri che devono essere letti
Se il secondo parametro è omesso verranno letti tutti i caratteri.
Se si vuole leggere una riga specifica è possibile usare
*CODICE*
$testo = FileReadLine ($handle_del_file, 5)
;oppure
*CODICE*
$testo = FileReadLine ("nomefile.txt", 5)
Il secondo parametro indica la linea da leggere
4. Chiudere un file:
Semplicemente
*CODICE*
FileClose ($handle_del_file)
5. Cancellare un file:
Basta usare
*CODICE*
FileDelete ("nomefile.txt")
Ovviamente esistono anche altre funzioni ma questo sono le principali e
le più usate
--------Strutture-Selettive----
----If...Then...Else...ElseIf...EndIf--
*CODICE*
Msgbox (0, "fraev has been here", "ehi, $x è uguale a 0, non so niente
di $y")
[Else]
Msgbox (0, "fraev has been here", "ehi, $x è diverso a 0, $y è diverso
da 0")
Endif
*CODICE*
If $x=0 Then
Msgbox (0, "fraev has been here", "ehi, $x è uguale a 0, non so niente
di $y")
[ElseIf $y=0] Then
Msgbox (0, "fraev has been here", "ehi, $x è diverso da 0, $y è uguale a 0")
[Else]
Msgbox (0, "fraev has been here", "ehi, $x è diverso a 0, $y è diverso
da 0")
Endif
If...Endif verifica una condizione posta tra If e Then;
se la condizione risulta vera esegue il codice sotto a Then (fino alla
successiva parola chiave)
Se invece risulta falso viene eseguito il codice sotto a Else (fino alla
successiva parola chiave)
ElseIf è una particolare condizione; affinchè venga eseguito il codice
sotto ElseIf la condizione tra If e Then deve essere falsa mentre la
condizione tra ElseIf e Then deve essere vera
EndIf va posto alla fine di ogni struttura If .. . Endif
Fate delle prove, presto verrà tutto naturale.
Chi non sopporta l'inglese può tradurre mentalmente le parole in italiano:
If => Se
Then => Allora
Else => Altrimenti
Laughing sembra una cavolata ma può aiutare molto.
----Select...Case...EndSelect--
*CODICE*
Select
Case $x>1
Msgbox (0, "", "$x è maggiore di 1")
Case $x>10
Msgbox (0, "", "$x è maggiore di 10")
Case Else
Msgbox (0, "", "$x è minore o uguale a 1")
Endselect
Select...EndSelect verifica le condizioni dopo ad ogni case ed esegue il
codice sotto il primo case che risulta vero
Nell'esempio non verrà mai fuori la finestra "$x è maggiore di 10"
perchè prima si trova la condizione $x>1 (vera quando $x>10)
----Switch...Case...EndSwitch--
*CODICE*
Switch $x
Case 1 to 3
Msgbox (0, "", "$x è compreso tra 1 e 3")
Case 4 to 5
Msgbox (0, "", "$x è compreso tra 1 e 3")
Case 6
Msgbox (0, "", "$x è uguale a 6")
EndSwitch
Switch...EndSwitch si comporta in modo simile a Select...EndSelect
In questa struttura però viene preso in esame una sola variabile che
viene scritta dopo Switch
Durante l'esecuzione viene verificato se il valore contenuto dentro alla
variabile è compreso dentro un range di valori.
Questo campo è definito dopo ogni case.
Esempio:
"1 to 3" comprende 1, 2 e 3
Se $x è uguale a 1, 2 o 3 la condizione risulta vera e viene eseguito il
codice sotto al primo Case
Definire un range non è obbligatorio; è possibile infatti specificare un
solo valore
--------Strutture-Iterative----
----For...To...Step...Next--
*CODICE*
For $x = 5 to 35 step 5
Msgbox (0, "AhiAhiAhi", "Non mi vengono in mente " & $x & " esempi più
stupidi di questo... -.-")
Next
Esegue il codice compreso tra For e Next incrementando ad ogni ciclo la
variabile dichiarata dopo 'For' ($x) del valore dichiarato dopo 'step'
(5), fino a quando non assume il valore dichiarato dopo 'to' (35)
Definire step non è obbligatorio; omettendo step il valore incrementa di 1
----While...WEnd--
*CODICE*
$counter = 0
$string = ""
While 1
$counter += 1
Switch $counter
Case 10
$string = @CRLF & "Cosa aspetti a terminarlo???"
Case 20
$string = @CRLF & "Cosa aspetti a terminarlo???" @CRLF & "Ma sei
matto?"
Case 30
$string = @CRLF & "Cosa aspetti a terminarlo???" & @CRLF & "Ma sei
matto?" & @CRLF & "Non hai niente di meglio da fare?"
Case 50
$string = @CRLF & "Cosa aspetti a terminarlo???" & @CRLF & "Ma sei
matto?" & @CRLF & "Non hai niente di meglio da fare?" & @CRLF & "Povero
demente..."
EndSwitch
Msgbox (0, "Ehi", "Questo codice andrà avanti all'infinito." & $string, 1)
Wend
Verifica la condizione posta dopo While e, se vera esegue il codice
sottostante
Con While è possibile generare facilmente un ciclo infinito. Basta
scrivere "While 1" cioè una condizione sempre vera
----Do...Until--
*CODICE*
$BabboNataleExists = FALSE
Do
Switch Msgbox (32+3, "Domanda: ", "Babbo Natale esiste?", 10) ; potevo
anche scrivere Msgbox (35, ...)
Case 2
Msgbox (0, "Mah", "Ah, non sai rispondere, eh?")
Case 6
Msgbox (0, "Mhm", "Teoria interessante...")
$BabboNataleExists = TRUE
Case 7
Msgbox (0, "-_-", "Ok, pensala come vuoi")
$BabboNataleExists = FALSE ; riga inutile (dopo c'è un exit) ma era
tanto per ricordare che Babbo Natale non esiste ;D
Exit
Case Else
Msgbox (0, "-_____-", "MUOVITI!!!", 30)
EndSwitch
Until $BabboNataleExists = TRUE
Esegue il codice compreso tra Do e Until fino a che non si verifica la
condizione posta dopo Until
Ovviamente questa condizione può anche non verificarsi mai. Anche questo
ciclo può quindi diventare un ciclo infinito...
----For...In...Next--
*CODICE*
Dim $array[5]
$array[0] = "Fraev"
$array[1] = "has"
$array[2] = "been"
$array[3] = "here..."
$array[4] = "and he's here now..."
Msgbox (48, "Attenzione", "Ora presenteremo il contenuto dell'array
$array in 5 msgboxes." & @CRLF & "La visione e consigliata a un pubblico
adulto non impressionabile." & @CRLF & "Buona visione." )
For $x in $array
Msgbox (0, "asd", $x)
Next
Esegue il codice compreso tra For e Next per ogni elemento di un array e
attribuisce alla variabile compresa tra For e In tutti i valori dell'array
[questa struttura viene anche utilizzata per lavorare sugli objects...
ne parleremo più avanti; se vi interessa consultate il manuale di AutoIt]
----Creare-una-GUI--
*CODICE*
#include <GUIConstants>
$Form = GUICreate("GUI", 216, 132)
$Label = GUICtrlCreateLabel("Che bella GUI! (senza doppisensi)", 24, 24,
163, 17)
$Button = GUICtrlCreateButton("Io penso di essere un bottone", 16, 72,
185, 33)
GUISetState(@SW_SHOW)
While 1
$Msg = GUIGetMsg()
Switch $Msg
Case $GUI_EVENT_CLOSE
Exit
EndSwitch
WEnd
Creare un interfaccia grafica in AutoIt è molto semplice.
Quando si crea un Form è bene includere GUIConstants.au3 così da poter
usufruire di alcune variabili già preaparate dal team di AutoIt
*CODICE*
#include <GUIConstants>
Ora passiamo alla creazione vera e propria del Form, la finestra del
nostro programma. Per questo inseriamo la funzione GUICreate ("titolo")
*CODICE*
$Form = GUICreate("GUI", 216, 132)
Il primo parametro indica il titolo della finestra;
Il secondo e il terzo parametro indicano rispettivamente larghezza e
altezza della nostra finestra;
Il quarto e quinto parametro indicano invece la posizione della finestra
nello schermo;
il sesto e settimo parametro indicano gli stili della finestra, ovvero
dei paramatri che consentono alla vostra finestra di assumere delle
praticolari proprietà. Per un elenco completo di queste proprietà
consultate l'help di AutoIt
L'ottavo parametro consente di indicare una finestra "madre" per la
finestra creata
E' importante notare che solo il primo parametro è obbligatorio. Tutti
gli altri parametri hanno un valore di default che verrà applicato nel
caso manchi qualche parametro.
Usando il comando GUICreate () si crea l'handle della finestra
(l'oggetto sul quale verranno creati i controlli)
Dopo aver creato la nostra finestrella, procediamo a popolarla di
controlli (come bottoni, textbox, liste, etc)
Per creare un controllo in una finestra è sufficiente usare il comando
GUICtrlCreate*
L'* va sostituito con il nome del controllo
Per creare un bottone (button in inglese Razz) ad esempio:
*CODICE*
$Button = GUICtrlCreateButton("Io penso di essere un bottone", 16, 72,
185, 33)
Il primo parametro indica il testo presente nel bottone
Il secondo e il terzo parametro indicano la posizione
Il quarto e il quinto parametro indicano la dimensione del controllo
il sesto e settimo parametro indicano gli stili del controllo, ovvero
dei paramatri che consentono ai vostri controlli di assumere alcune
prorprietà particolari
Questa è una sorta di traccia usata da molti controlli. Ovviamente
alcuni controlli necessitano di più di un parametro ma le strutture dei
GUICtrlCreate* sono molto simili tra loro
IMPORTANTE: Da un controllo ritorna sempre l'handle del controllo che
verrà usato in seguito per gestire l'interazione con i controlli.
Dopo aver definito i controlli da usare nel Form settiamo lo stato della
finestra con il comando
*CODICE*
GUISetState(@SW_SHOW)
A GUISetstate possono essere passati due parametri:
Il primo indica lo stato che la finestra deve assumere; il secondo
indica l'handle della finestra in questione
Se il secondo parametro non viene inserito viene utilizzata l'ultimo
form creato
Infine, la parte più divertente, definiamo cosa deve succedere quando
l'utente preme un bottone o interagisce con un controllo.
Per questo dobbiamo usare un ciclo infinito: il programma controllerà
ogni secondo se qualche controllo è stato usato e reagirà di conseguenza.
Bene, cominciamo a creare un ciclo infinito While...WEnd
*CODICE*
While 1
Wend
Poi utilizziamo la funzione GUIGetMsg() che rileva le interazioni con i
controlli e diciamo al programma di salvare il suo valore dentro una
variabile
*CODICE*
While 1
$Msg = GUIGetMsg ()
Wend
Ora creaiamo una struttura di selezione Switch sul valore di $Msg
(ovvero le interazioni con i controlli)
$Msg assumerà il valore dell'handle del controllo che è stato usato,
quindi organizziamo così il nostro Switch
*CODICE*
While 1
$Msg = GUIGetMsg ()
Switch $msg
Case $button
Msgbox (0, "Ehi!", "Vacci piano con quel mouse!" & @CRLF & "Noi
poveri controlli ci pungiamo sempre")
EndSwitch
Wend
Bene solo un ultima cosa:
In AutoIt vengono attribuiti dei valori particolari ai tasti per
ridimensionare, minimizzare e chiudere la finestra.
Per poterli usare è necessario includere GUIConstants.au3
Sono semplicemente delle variabili che possono essere usate come bottoni
normali:
$GUI_EVENT_CLOSE = il tasto per chiudere la finestra
$GUI_EVENT_MINIMIZE = il tasto per minimizzare la finestra
$GUI_EVENT_RESTORE = il click sulla barra di windows per ripristinare la
finestra
$GUI_EVENT_MAXIMIZE = il tasto per massimizzare la finestra
*CODICE*
While 1
$Msg = GUIGetMsg ()
Switch $msg
Case $button
Msgbox (0, "Ehi!", "Vacci piano con quel mouse!" & @CRLF & "Noi
poveri controlli ci pungiamo sempre!!!")
Case $GUI_EVENT_CLOSE
Exit
EndSwitch
Wend
----Inviare-eventi-tastiera--
In questa lezione vedremo come inviare pressioni di tasti a windows
(proprio come se qualcuno stesse usando la nostra tastiera e il nostro
mouse)
Il primo comando che prenderemo in considerazione è Send("tasto") che
invia delle combinazioni di tasti.
*CODICE*
[/CODE]
Send ("!x")
Se il secondo parametro viene settato a 1, i caratteri verranno inviati
come sono scritti.
Questa modalità viene usata per inserire del testo; si è infatti sicuri
che il testo inserito sarà uguale a ciò che risulterà in output
[CODE]Send ("#adi8wa(/(=/", 1)
darà come output #adi8wa(/(=/
Se il secondo parametro di Send è settato a 0 o è lasciato di default
tutti i caratteri verranno inviati come vengono scritti tranne:
! = ALT
+ = SHIFT
^ = CTRL
# = WIN
e alcune combinazioni necessarie per indicare alcuni tasti speciali
*CODICE*
Send("^!x")
invierà CTRL+ALT+X
Nell'help ufficiale è presente una lista completa con tutti i caratteri
speciali
E inoltre possibile dare particolari istruzioni a send:
*CODICE*
Send ("{A 4}")
invierà A 4 volte.
*CODICE*
Send("{a down}")
terrà schiacciato virtualmente il tasto a
*CODICE*
Send("{a up}")
rilascerà il tasto a
Con Numlock, CapsLock e SCrollLock toggle si possono usare anche le
opzioni on/off/toggle per attivare e disattivare il lock
Send("{NumLock on}")
Send("{CapsLock off}")
Send("{ScrollLock toggle}")
----Inviare-eventi-mouse--
In AutoIt è possibile controllare il mouse attraverso alcune semplici
funzioni:
MouseClick: Invia un click del mouse.
*CODICE*
MouseClick("left", 10, 10, 2, 20)
E' necessario impostare che tasto inviare ("Left","Right","Middle", etc)
passando come primo parametro una stringa.
Il secondo e il terzo parametro individuano le coordinate x/y alle quali
verrà effettuato il click
Il quarto parametro riguarda il numero di clicks da effetuare
Il quinto parametro invece indica la velocità[0-100] alla quale il mouse
dovrà spostarsi alle coordinate x/y; 0 è istantaneo, 100 è il più lento
MouseCickDrag: Trascina il mouse da una coordinata a un altra
*CODICE*
MouseClickDrag("left", 10, 10, 20, 10, 0)
Il primo parametro indica il tasto che verrà utilizzato nella funzione
Il secondo e il terzo parametro individuano le coordinate x/y di partenza
Il quarto e il quinto parametro individuano le coordinate x/y di arrivo
Il sesto parametro indica ancora una volta la velocità[0-100]
MouseMove: Sposta il mouse
*CODICE*
Mousemove(10, 10, 100)
Il primo e il secondo parametro individuano le coordinate nelle quali le
coordinate devono spostarsi
Il terzo parametro indica la velocità[0-100]
MouseGetPos: Ritorna informazioni sul mouse
*CODICE*
$array = MouseGetPos()
Msgbox (0, "Il tuo mouse è qui: ", "X: " & $array[0] & @CRLF & "Y: " &
$array[1])
Se nessun parametro è specificato ritorna un array bidimensionale
contenente in [0] la coordinata x e in [1] la coordinata y
Se viene specificato come primo parametro 0, ritorna la coordinata x; se
viene specificato 1, ritorna y
MouseGetCursor: Ritorna il cursore del mouse
Trovate la lista completa nell'help ufficiale
MouseDown: Tiene premuto un tasto del mouse
Si passa come primo parametro il tasto da tenere premuto
MouseUp: Smette di premere un tasto del mouse
Si passa come primo parametro il tasto da "liberare"
MouseWheel: Invia lo scroll di una rotellina
*CODICE*
MouseWheel ( "down" ,23); questa è l'indicazione per l'inferno: down +
[2/3=0.666666] :lol:
Come primo parametro si passa la direzione, "up" o "down"
COme secondo parametro il numero di volte che verra effettuato lo scroll
(di default è 1)
_MouseTrap: Confina il mouse in un area di schermo ] : D
*CODICE*
#include <Misc>
MsgBox (0, "Crea la tua prigione", "Indica i 2 angoli che delimiteranno
la tua prigione")
Sleep (1000)
MsgBox (0, "Crea la tua prigione", "Indica l'angolo in alto a sinistra e
premi [OK] usando [INVIO]")
$upleft = MouseGetPos ()
Sleep (1000)
MsgBox (0, "Crea la tua prigione", "Indica l'angolo in basso a destra e
premi [OK] usando [INVIO]")
$downright = MouseGetPos ()
Sleep (2000)
MsgBox (0, "Crea la tua prigione", "Bene tra un attimo sarai in
trappola!" & @CRLF & "Per uscire premi il tasto Home")
_MouseTrap ($upleft[0], $upleft[1], $downright[0], $downright[1])
While 1
If _IsPressed (24) Then
_MouseTrap ()
Exit
EndIf
WEnd
Questa funzione, semplicemente stupenda era in origine un UDF che è
stato poi inserito nella versione ufficiale di AutoIt (lo si può capire
dal _ che precede la funzione)
Per funzionare richiede Misc.au3
Bisogna solo passare le coordinate per l'angolo in alto a sinistra e per
l'angolo in basso a destra
----Scrivere-leggere-e-cancellare-in-regedit--
Per scrivere un valore nel registro possiamo usare la funzione RegWrite
*CODICE*
RegWrite("HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run",
"Shutdown" , "REG_SZ", @WindowsDir & "System32\RUNDLL32.EXE
user.exe,exitwindows" )
Il primo parametro indica la posizione nella quale verrà creata la
nostra chiave di registro
Il secondo parametro indica il nome della chiave
Il terzo parametro indica il tipo di chiave
Il quarto parametro indica il valore da scrivere nella chiave
Se verrà specificato solo il primo parametro verrà creata il percorso se
non esistente
Sono sicuro che tutti abbiamo capito cosa fa il codice dell'esempio
Laughing Laughing
Aggiunge all'avvio di Windows un collegamento che spegne il computer
Twisted Evil
Per leggere un valore usiamo la funzione RegRead
*CODICE*
RegRead(HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run",
"Shutdown")
Con il primo parametro specifichiamo il percorso della chiave da leggere
Con il secondo invece indichiamo il nome della chiave
L'esempio ritornerà @WindowsDir & "System32\RUNDLL32.EXE
user.exe,exitwindows"
Per cancellare una chiave usiamo invece RegDelete
*CODICE*
RegDelete
("HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run",
"Shutdown")
Come abbiamo già visto in RegRead con il primo parametro specifichiamo
il percorso della chiave da cancellare
Con il secondo invece indichiamo il nome della chiave da cancellare
----Operazioni sulle finestre--
Nelle precedenti abbiamo imparato a creare finestre; ora daremo un
occhiata alla loro gestione.
Tutte le finestre di windows hanno un identificatore (handle) con i
quali possiamo richiamare le finestre all'interno del programma
Prima di tutto vediamo come recuperare informazioni sulle finestre che
vediamo.
Per raggiungere il nostro scopo usiamo il gruppo di funzioni WinGet*;
Con queste funzioni possiamo, dato il titolo e (se vogliamo) una parte
del testo della finestra recuperare l'handle della finestra, l'id del
processo, il testo e il titolo esatto, la classe della finestra, etc...
*CODICE*
ProcessClose (WinGetProcess(InputBox ("Finestra da chiudere", "Inserisci
il titolo della finestra da chiudere:")))
per coloro a cui non piace il codice precedente: Wink
*CODICE*
$title = InputBox ("Finestra da chiudere", "Inserisci il titolo della
finestra da chiudere:")
$pid = WinGetProcess($title)
ProcessClose ($pid)
Piccola parentesi su WinGetTitle:
Se si specifica un titolo vuoto in WinGetTitle la funzione ritornerà il
titolo della finestra attiva
WinGetTitle (""); finestra in primo piano
Piccola parentesi su WinGetState:
Per leggere lo stato di una finestra dobbiamo usare BitAND () in questo modo
*CODICE*
BitAND(WinGetState(WinGetTitle("")), $value)
con $value uguale al valore dello stato che ci interessa conoscere (date
un occhio alla guida ufficiale per la tabella completa degli stati);
BitAND ritornerà 1 se lo stato è attivo nella finestra specificata, 0 in
caso contrario
AutoIt mette nelle nostre mani da coder consumati delle funzioni
decisamente potenti; possiamo eseguire molte operazioni sulle finestre
Con WinActivate possiamo dare il focus a una determinata finestra, con
WinActive controlliamo se una finestra è attiva o meno;
Con WinClose chiudiamo una finestrea, con WinKill forziamo la sua chiusura;
Con WInlist recuperiamo un array bi-dimensionale contenente titoli e
handle di tutte le finestre aperte (comprese le finestre nascoste);
Con WInMove possiamo spostare la nostra finestra;
Con il gruppo di funzioni WinWait* (-, Active, NotActive, Close)
possiamo stoppare l'esecuzione dello script fino a quando una finestra
non esista, sia attiva o venga chiusa
Con il gruppo di funzioni WinSet* possiamo settare stato, titolo,
trasparenza e proprietà (come sempre in primo piano) di una finestra.
*CODICE*
WinWaitActive ("doh.txt")
WinSetTrans(WinGetTitle(""), "", 180)
WinSetOnTop (WinGetTitle(""), "", 1)
Per specificare il titolo in una funzione Win* esistono 4 modalità:
1. (default) controlla che il titolo di una finestra cominci per la
stringa inserita
2. Controlla che nel titolo di una finestra sia presente la stringa inserita
3. Controlla che il titolo di una finestra sia perfettamente uguale alla
stringa inserita
4. Controlla particolari campi di una finestra
il 4 metodo usa una sintassi particolare.
In una funzione, nel parametro titolo, sarà necessario inserire,
[nome_del_campo:stringa-da-cercare-nel-campo]
nome_del campo può essere il titolo (TITLE), la classe (CLASS), etc
(vedi guida ufficiale per la tabella dei campi)
stringa-da-cercare-nel-campo è invece la stringa che bisognerà ricercare
nel campo specificato
Più campi possono essere separati dal punto e virgola
*CODICE*
WinClose("[LAST]")
*CODICE*
WinClose("[TITLE:7.hmtl ; CLASS:Notepad]")
Per selezionare un metodo possiamo usare Opt("WinTitleMatchMode",
$numero_della_modalità)
*CODICE*
Opt("WinTitleMatchMode", 2)
$list = WinList ("")
For $x = 1 to $list[0][0]
WinSetTrans ("Mozilla-Firefox",150)
Next
*SPOILER* (clicca per visualizzare <jspoiler()>)
Il comando Send
Il comando Send in autoIt è molto utile per molte cose,
viene utilizzato per simulare la pressione di tasti sulla tastiera come
per esempio
Codice:
;Comando Send
send(”a”)
Questo codice permette di stampare la lettera a come se l’utente
l’avesse premuto
e possibile far scrivere anche frasi o parole;Es:
Codice:
Send(”Ciao Mondo”)
questo sorgente stampa la frase Ciao Mondo.
E’ possibile premere combinazioni di tasti come per esempio:
Codice:
send(”Lettera +maisucola”)
vedrete ke si visualizzerà la scritta Lettera Maiuscola (Nota bene la M)
questo perchè il comando send simula con il carattere + la pressione del
tasto SHIFT seguito dalla lettera m.
quì vi riporto tutti i caratteri speciali:
! = Comando ALT (N.B. Se inserite il comando in questo modo {Send(”!A”)}
sarà come se premeste ALT-SHIFT-A quindi inserite insieme a questo
comando i caratteri minuscoli)
+ = Comando SHIFT
^ = Comando CTRL
# = Comando Windows(Esempio:Send(”#r”))
SHIFTDOWN = Comando ke tiene premuto il tasto sSHIFT
SHIFTUP = Comando ke rilascia il tasto SHIFT
Questa di seguito è una lista completa dei delle funzioni:
{!} = !
{#} = #
{+}= +
{^}= ^
{{} ={
{}} =}
{SPACE}= Spazio
{ENTER}= Invio
{ALT} = ALT
{BACKSPACE} or {BS} = BACKSPACE
{DELETE} or {DEL}= DELETE
{UP} =Up arrow
{DOWN} Down arrow
{LEFT} Left arrow
{RIGHT} Right arrow
{HOME} HOME
{END} END
{ESCAPE} or {ESC} ESCAPE
{INSERT} or {INS} INS
{PGUP} PageUp
{PGDN} PageDown
{F1} - {F12} Function keys
{TAB} TAB
{PRINTSCREEN} Print Screen key
{LWIN} Left Windows key
{RWIN} Right Windows key
{NUMLOCK on} NUMLOCK (on/off/toggle)
{CAPSLOCK off} CAPSLOCK (on/off/toggle)
{SCROLLLOCK toggle} SCROLLLOCK (on/off/toggle)
{BREAK} for Ctrl+Break processing
{PAUSE} PAUSE
{NUMPAD0} - {NUMPAD9} Numpad digits
{NUMPADMULT} Numpad Multiply
{NUMPADADD} Numpad Add
{NUMPADSUB} Numpad Subtract
{NUMPADDIV} Numpad Divide
{NUMPADDOT} Numpad period
{NUMPADENTER} Enter key on the numpad
{APPSKEY} Windows App key
{LALT} Left ALT key
{RALT} Right ALT key
{LCTRL} Left CTRL key
{RCTRL} Right CTRL key
{LSHIFT} Left Shift key
{RSHIFT} Right Shift key
{SLEEP} Computer SLEEP key
{ALTDOWN} Holds the ALT key down until {ALTUP} is sent
{SHIFTDOWN} Holds the SHIFT key down until {SHIFTUP} is sent
{CTRLDOWN} Holds the CTRL key down until {CTRLUP} is sent
{LWINDOWN} Holds the left Windows key down until {LWINUP} is sent
{RWINDOWN} Holds the right Windows key down until {RWINUP} is sent
{ASC nnnn} Send the ALT+nnnn key combination
{BROWSER_BACK} 2000/XP Only: Select the browser “back” button
{BROWSER_FORWARD} 2000/XP Only: Select the browser “forward” button
{BROWSER_REFRESH} 2000/XP Only: Select the browser “refresh” button
{BROWSER_STOP} 2000/XP Only: Select the browser “stop” button
{BROWSER_SEARCH} 2000/XP Only: Select the browser “search” button
{BROWSER_FAVORITES} 2000/XP Only: Select the browser “favorites” button
{BROWSER_HOME} 2000/XP Only: Launch the browser and go to the home page
{VOLUME_MUTE} 2000/XP Only: Mute the volume
{VOLUME_DOWN} 2000/XP Only: Reduce the volume
{VOLUME_UP} 2000/XP Only: Increase the volume
{MEDIA_NEXT} 2000/XP Only: Select next track in media player
{MEDIA_PREV} 2000/XP Only: Select previous track in media player
{MEDIA_STOP} 2000/XP Only: Stop media player
{MEDIA_PLAY_PAUSE} 2000/XP Only: Play/pause media player
{LAUNCH_MAIL} 2000/XP Only: Launch the email application
{LAUNCH_MEDIA} 2000/XP Only: Launch media player
{LAUNCH_APP1} 2000/XP Only: Launch user app1
{LAUNCH_APP2} 2000/XP Only: Launch user app2
è possibile premere anche combinazioni di tasti come
Codice:
;Presses SHIFT+TAB 4 times
Send(”+{TAB 4}”)
Oppure
Codice:
;Holds the A key down
Send(”{a down}”)
è possibile settare anche i tasti Numlock,capslock,Scrollock
Codice:
;To set the state of the capslock, numlock and scrolllock keys
Send(”{NumLock on}”) ;Turns the NumLock key on
Send(”{CapsLock off}”) ;Turns the CapsLock key off
Send(”{ScrollLock toggle}”) ;Toggles the state of ScrollLock
lista di secuenze utilizzabili:
Send(”{TAB}”) Navigate to next control (button, checkbox, etc)
Send(”+{TAB}”) Navigate to previous control.
Send(”^{TAB}”) Navigate to next WindowTab (on a Tabbed dialog window)
Send(”^+{TAB}”) Navigate to previous WindowTab.
Send(”{SPACE}”) Can be used to toggle a checkbox or click a button.
Send(”{+}”) Usually checks a checkbox (if it’s a “real” checkbox.)
Send(”{-}”) Usually unchecks a checkbox.
Send(”{NumPadMult}”) Recursively expands folders in a SysTreeView32.
Send(”{DOWN}”) Move down a menu.
Send(”{UP}”) Move up a menu.
Send(”{LEFT}”) Move leftward to new menu or expand a submenu.
Send(”{RIGHT}”) Move rightward to new menu or collapse a submenu.
Questo è un piccolo esempio su come utilizzare i vari comandi
Codice:
;Apri il Blocco note
Run(”notepad.exe”)
;Mette in pausa lo script per 1 secondo
sleep(1000)
;Scrive ciao
Send(”Ciao”)
;Và a capo
Send(”{ENTER}”)
;Scrive mondo maiuscolo,visto ke il comando SHIFTDOWN simula la
pressione continuata dello SHIFT
Send(”{SHIFTDOWN}mondo”)
;Fà ritornare lo shift al suo posto altreimenti rimarrebbe sempre premuto
Send(”{SHIFTUP}”)
Nel blocco note se premete il tasto F5 spunta la data be questo è il
comando ke simula la pressione del tasto in questione
send(”La data di oggi è {F5}”)
Crediti: Autoit Funclub
RE: AutoIT - GUIDA GENERALE - almatt - 12-10-2012 10:04 PM
Guida copiata o stato copiata da if .