Total Hack Cheat
Benvenuto/a su Total hack Cheat....
non aspettate altro tempo Registratevi!!

Guida Programmare in AutoIT

Vedere l'argomento precedente Vedere l'argomento seguente Andare in basso

Guida Programmare in AutoIT

Messaggio Da RaYoZ il Sab Set 04, 2010 1:49 am

AutoIT è un linguaggio di programmazione derivato dal VisualBasic, Pearl e altri linguaggi. La sintassi è molto intuitiva e con esso si possono creare GUI (interfacce grafiche) e file eseguibili (.exe), ma la cosa più interessante è che esso non dipende minimamente dalle librerie DLL, se non da quelle del sistema.
Per iniziare a programmare in AutoIT, dobbiamo scaricare il pacchetto completo dal sito e installarlo selezionando Full Installation.

-Ora andiamo su Start-> Tutti i programmi-> AutoIt v3-> SciTE Script Editor e si aprirà l'editor degli script AutoIT.
Per creare i nostri programmi dovremo inserire il codice lì, e per farlo partire dovremo premere F5.
Iniziamo con una semplice funzione: il MsgBox, il Messaggio.
Scriviamo questa riga e premiamo F5
MsgBox (0, "Questo è un titolo", "Questo è un messaggio")
Se l'avete scritto e non incollato, avrete notato certamente il popup che vi consiglia o ricorda le parole usate in AutoIT che iniziano con la lettera digitata.
Ora analizziamo il codice:

* MsgBox: è la parola che si usa per i messaggi. I programmatori in VisualBasic la conoscono molto bene, essendo AutoIT derivato dal VisualBasic.

* 0: è la "flag" del messaggio. Essa setta il tipo di messaggio, ad esempio se è un Alert o una dialog con scritte "Ok, No, Annulla" e così via.

* "Questo è un titolo": Il titolo del messaggio.

* "Questo è un messaggio": È il testo del messaggio .

Abbiamo quindi imparato come far stampare sullo schermo dei messaggi.

Ora vediamo le variabili.
Cosa sono esse?
Immaginiamoci tanti vasi e in ognuno di essi un fiore diverso. Ogni vaso è una variabile. In pratica ad ogni variabile corrisponde un valore. Come possiamo riconoscere le variabili in autoit? Esse sono precedute dal $ e la loro sintassi è questa:
$variabile = "Ciao!"

Ora proviamo a creare una MsgBox e inserire la variabile. Il codice sarà questo:
MsgBox(0, "", $variabile)
Come potremo vedere, nel testo apparirà il valore della variabile, ad esempio un numero o una stringa. Sperimentate ancora, è molto divertente .
Ricordiamo che ad ogni funzione ritorna un sempre un valore e che in AutoIT possiamo concatenare le funzioni. Ad esempio la funzione StringUpper restituisce il testo in maiuscolo. Possiamo provare scrivendo
Msgbox (0, "Cosa è questo?", StringUpper ( "un bellissimo linguaggio di programmazione!" )
Come possiamo vedere, nel MsgBox ci sarà una scritta in minuscolo convertita in maiuscolo.

Ora vediamo cosa sono le macro. Le macro sono dei tipi di variabili che però il programmatore non può modificare. Cominciano tutte con la @. Per una lista completa delle macro, potete visualizzare la documentazione ufficiale QUI.
Vediamo la macro per inserire degli spazi in un MsgBox.
Il codice è il seguente:
Msgbox (0, "Questo è...", "Auto..." & @CRLF & @CRLF & "..." & @CRLF & @CRLF & "IT!!")
In AutoIT per legare variabili e macros a stringhe, si usa la lettera &.
Quindi se vogliamo legare una variabile con una stringa di testo faremo una cosa del genere:
$var1 = "AutoIT" $var2 = "regna?" MsgBox(0, "Sai che...", $var1 & var2)

Ora che abbiamo imparato anche cosa sono le macro, procediamo con gli Array.
Cosa sono gli array? Possiamo immaginarceli come dei pacchi che contengono delle scatole ordinate. Per aggiungere delle "scatole" a questi "pacchi" (aahahha che frase ) dobbiamo scrivere
dim $array[5] = ["valore", "altro", "altro ancora", "e", "così via"]
mentre per lavorare con esse c'è la funzione _Array*
Le funzioni sono delle cose semplicissime, non ci soffermiamo molto su di esse proprio per questo. Prendiamo come esempio StringSplit per interagire proprio con gli array
$array = StringSplit ("MondoeMule è un blog che tratta molti argomenti d'informatica", " ")
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]=9 $array[1]="MondoeMule", $array[2]="è", $array[3]="un", $array[4]="blog" e così via fino a "d'informatica".

Adesso impariamo come interagire con i files: Aprirli, Scriverli, Leggerli e Chiuderli.
Per interagire con i files la funzione è _File* e File*.
Una stringa per aprirli è ad esempio
$handle = FileOpen ("documento.txt", $mode)
Il $mode rappresenta che stiamo aprendo il 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
Per scrivere nel documento, useremo il FileWriteLine che aggiunge un @CRLF alla fine. Il code da utilizzare è il seguente:
FileWrite ($handle, "AutoIT È Un Ottimo Linguaggio Di Programmazione")
o anche
FileWrite ("documento.txt", "AutoIT È Un Ottimo Linguaggio Di Programmazione").
La cosa che li differenzia è che con la prima opzione è possibile tenere sempre aperto il file, mentre con la seconda no.
Per leggere i files si fa così:
$var1 = FileRead ($handle, 100)
o come altra possibilità
$var2 = FileRead ("nomefile.txt", 100)
Il parametro 100 indica i caratteri da leggere. Se non viene inserito questo parametro verranno letti tutti. Se desideriamo leggere una sola riga, possiamo usare la funzione FileReadLine dove il parametro numerico indica la linea da leggere.
Per chiudere un file il codice da utilizzare è
FileClose ($handle)
mentre per cancellarne uno è
FileDelete ("nomefile.txt").
Detto questo possiamo passare alle strutture selettive: If, ElseIf e Else.
Se non masticate molto l' inglese, If = Se, ElseIf = Altrimenti Se, Else = Altrimenti, Then = allora.
Può sembrare banale, ma sapere il significato di queste tre piccole parole può aiutare moltissimo a capire questo punto.
$var = "ciao"
If $var = "ciao" Then
MsgBox(0, "Benvenuto", "Benvenuto alla guida sulle strutture If,Elseif,Else")
Else
MsgBox(0, "Nono!!!", "Eh no! $var non è 'ciao'! Quindi non si fa niente..")
Questo piccolo esempio fa sì che AutoIT controlli che $var abbia il valore "ciao". Se var ha il valore ciao, stamperà un messaggio con scritto "Benvenuto alla guida sulle strutture If,ElseIf,Else" altrimenti darà il messaggio scritto nel MsgBox dopo l'Else.
Fate molte prove con questo esempio fino a capire bene come funziona.
Ora guardiamo i Select e i Case.
Select Case
$var>10
Msgbox (0, "", "$x è maggiore di 10")
Case $var>20
Msgbox (0, "", "$x è maggiore di 20")
Case Else
Msgbox (0, "", "$x è minore o uguale a 1")
EndSelect

Select verifica la condizione sotto ogni case e esegue le istruzioni della condizione vera.

Gli switch sono simili ai select, l'unica cosa è che la variabile viene specificata subito dopo lo switch e verrà esaminata solo quella.
Viene verificato se la variabile è compresa nel range di valori specificati, ad esempio, se $var è 2, l'istruzione vera sarà Case 1 to 3:
Switch $var
Case 1 to 3
Msgbox (0, "", "$var è compreso tra 1 e 3")
Case 4 to 5
Msgbox (0, "", "$var è compreso tra 1 e 3")
Case 6
Msgbox (0, "", "$var è uguale a 6")
EndSwitch

Ora guardiamo alcune strutture iterative.
For - Next è una struttura molto semplice che esegue il codice compreso tra For e Next e incrementa ad ogni ciclo la variabile dichiarata dopo For.
Ad esempio
For $var = 1 to 40 step 1
Msgbox (0, "Contiamo!", "Contiamo fino a 40:" & $var )
Next
"1 to 40 step 1" specifica che la variabile $var deve aumentare di un numero ad ogni ciclo.

Ora vediamo i While.
Per spiegare la sintassi di un while, farò un esempio molto semplice.
While 1 = 1
Run("notepad.exe")
WEnd
Che tradotto in italiano significa: finchè 1 è 1 (cioè sempre), apro notepad.exe ( il note pad di windows).

Un'altra cosa molto interessante è il Do-Until. La sintassi è la seguente
Do
For $var = 1 to 5 step 1
Until $var = 5
Do-Until esegue una precisa istruzione finchè non si presenta la situazione di chiusura specificata in Until.

Il For...in...next è simile al For-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. Esempio:
Dim $array[2]
$array[0] = "Questo è...."
$array[1] = "Mondo"
$array[2] = "eMule!"
For $var in $array
MsgBox(0, "Titolino^^", $var)
Next
In questo caso usciranno 3 MsgBox con scritto ad ognuna di esse un valore di ogni array.
Con questo piccolo tutorial su cicli, array, variabili abbiamo preso dimestichezza con AutoIT...ma ora passiamo alla parte più interessante: le GUI!

Per creare una GUI dobbiamo prima di tutto includere GUIcostants in modo da dover creare meno variabili possibili, essendo state create dallo staff di AutoIT.
#include GUICostants
Adesso creiamo la finestra. La funzione specifica è GUICreate("Titolo", larghezza, altezza). In caso si omettano i parametri larghezza e altezza, verranno impostati quelli di default. Ad esempio
GUICreate("Prima GUI", 800, 600)
Ora che abbiamo creato la finestra, passiamo al riempirla con bottoni, textboxes e altri controlli. La funzione per aggiungere un controllo è GUICtrlCreate*, dove * deve essere sostituito da un oggetto. Ad esempio per un tasto, la funzione è GUICtrlCreateButton.
Ora inseriamo il bottone dentro la finestra:
$Botton = GUICtrlCreateButton("Tasto^^", 400, 200, 185, 33)
Benissimo! Ora non ci resta che rendere il form visibile. Il codice per rendere visibile il form è
GUISetState(@SW_SHOW)
@SW_SHOW è lo stato che assumerà la GUI in questo caso. Mi raccomando di non incollare MAI il codice come lo leggete qui, perchè se lo scrivete, vi esce la finestra a tendina che vi aiuterà a capire meglio la funzione con i vari parametri aggiuntivi.

Ora impariamo la cosa più simpatica delle GUI...controllare se un controllo è in funzione e far reagire il programma! Sembra una cosa complessa, ma non lo è. Tutto sta nel capire e pensare come se fossimo il compilatore, ma con fantasia.
Inseriamo un while che faccia uscire un messaggio quando noi clicchiamo sul bottone:
While 1 = 1
$msg = GUIGetMsg ()
Switch $msg
Case
$button Msgbox (0, "Bravo hai cliccato sul tastino ^^")
EndSwitch Wend
Cosa abbiamo inserito nel while? GUIGetMsg() è una funzione che si occupa di rilevare le interazioni tra i controlli e l'abbiamo associato alla variabile $msg, in seguito abbiamo inserito uno switch su $msg per l'interazione del controllo. Perfetto, ora non ci resta che una cosa: istruire i tasti per chiudere, massimizzare e ridurre a icona. In autoit, grazie alla libreria GUICostants.au3, ci sono delle variabili a posta create:
$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
Quindi per attribuire al tasto [X] la funzione di chiusura, basta inserire un case con $GUI_EVENT_CLOSE. Il codice quindi diventa
While 1 = 1
$msg = GUIGetMsg ()
Switch $msg
Case $button Msgbox (0, "Bravo hai cliccato sul tastino ^^")
Case $GUI_EVENT_CLOSE
Exit
EndSwitch
Wend
e abbiamo così imparato a scrivere delle GUI.

Ma con AutoIT si possono fare cose ancora più avanzate, ad esempio mandare input della tastiera e dal mouse virtualmente. Si potrebbe usare questo metodo per creare una GUI per una tastiera virtuale.
Vediamo come funzionano questi input.
Per "schiacciare" un tasto, la funzione è:
Send(!*)
dove * verrà sostituito dalla lettera. Per fare delle combo (combinazioni) tipo Ctrl+Alt+Canc, si possono usare dei caratteri speciali. Essi sono
! = ALT
+ = SHIFT
^ = CTRL
# = WIN
Poi possiamo anche mandare istruzioni speciali al send, come ad esempio
Send("{C 18}")
che invierà 18 volte la lettera C
Send("{A down}")
che terrà premuto la lettera A
Send("{B down}")
che rilascierà la lettera B.
Per le altre opzioni speciali, come il Caps lock, Num Lock, Scroll Lock, ci sono altre apposite funzioni:
Send("{NumLock on}")
Send("{CapsLock off}")
Send("{ScrollLock toggle}")

Ora che abbiamo visto gli input tastiera, passiamo agli input mouse.
La funzione è MouseClick (mi chiedo sempre chi inventa questi nomi così originali :-)). Ora analizziamo un esempio
MouseClick("left", 10, 10, 2, 20)
Il primo parametro riguarda il tasto, il secondo e il terzo le coordinate x/y, il quarto riguarda il numero di click e l'ultimo l'intervallo di movimento. Se è impostato 0, il movimento da x a y sarà istantaneo. Se si setta 100 sarà molto lento. Per muovere soltanto il mouse senza cliccare, la funzione è Mousemove(10, 10, 100)
dove il primo e il secondo parametro sono le coordinate e il terzo la velocità. Se vogliamo sapere dove si trova il mouse, c'è l'apposita funzione MouseGetPos(). Creando un array e una msgbox possiamo farci dire da AutoIT dove si trova adesso:
$array = MouseGetPos()
Msgbox (0, "Il tuo mouse è qui: ", "X: " & $array[0] & @CRLF & "Y: " & $array[1])
Ci sono molte altre funzioni, quali
MouseGetCursor: Ritorna il cursore del mouse
MouseDown: Tiene premuto un tasto del mouse
MouseUp: Smette di premere un tasto del mouse
MouseWheel: Invia lo scroll di una rotellina
e ricordo che per qualsiasi approfondimento potete visualizzare l'help ufficiale dal programma che specifica e approfondisce tutte le funzioni, parametri & Co.

Se nel programma che volete sviluppare volete modificare/cancellare/aggiungere chiavi al registro del sistema, c'è l'apposita funzione Reg*.
Per scrivere nel registro, la funzione è RegWrite, es:
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
Per leggere una chiave del registro, si usa RegRead:
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
Per cancellare una chiave usiamo RegDelete:
RegDelete ("HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run", "Shutdown")
Come già abbiamo capito, il primo parametro indica il percorso della chiave e il secondo il valore.
Fino ad ora abbiamo imparato a creare le finestre. Ora impariamo a gestirle!
Ogni finestra ha un handle che la identifica con cui possiamo richiamarle all'interno del programma. Prima di tutto dobbiamo prendere le informazioni su di esse e per fare ciò ci sono le funzioni WinGet*.
Con queste funzioni possiamo recuperare l'handle della finestra, l'id del processo, il testo e il titolo esatto ecc..
ProcessClose ("WinGetProcess(InputBox("Chiudi una finestra", "Scrivi il titolo della finestra da chiudere")))
La funzione WinGetTitle("") serve a specificare il titolo della finestra, se verrà omesso il parametro, verrà selezionata la finestra attiva (quella su cui state lavorando ora, in primo piano).
Per conoscere lo stato di una finestra dobbiamo fare in questo modo:
BitAND(WinGetState(WinGetTitle("")), $valore)
con $valore uguale al valore dello stato che ci interessa conoscere (per la tabella degli stati sbirciate l'help ufficiale). Se lo stato è attivo, ritornerà 1; in caso contrario 0.

Con AutoIT 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 finestra, 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.
Ad esempio:
WinWaitActive ("Senza nome.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
WinClose("[LAST]")
WinClose("[TITLE:7.hmtl ; CLASS:Notepad]")
Per selezionare un metodo possiamo usare Opt("WinTitleMatchMode", $numero_della_modalità)
Opt("WinTitleMatchMode", 2)
$list = WinList ("")
For $x = 1 to $list[0][0]
WinSetTrans ("Mozilla-Firefox",150)
Next

RaYoZ
Admin
Admin

Messaggi : 1040
Punti : 2245
Data d'iscrizione : 03.04.10
Età : 22
Località : immerso nei pensieri

Tornare in alto Andare in basso

Vedere l'argomento precedente Vedere l'argomento seguente Tornare in alto

- Argomenti simili

 
Permesso di questo forum:
Non puoi rispondere agli argomenti in questo forum