TookKit-autohotkey_Simple automation of Windows and programs

The open-source tool AutoHotkey sends several tools into retirement. It unites hotkey and text macros and offers a scripting-language, which is more powerful than every batch-file and easier
to learn than the Windows-Scripting-Host. Beginners are able to start fast because of the scripting-language, similar to BASIC, contains a macro-recorder and syntax-checker. Advanced users are pleased with functions for graphical interfaces and a compiler,
creating *.exe-files, that can be run on other Computers.
It isn't possible to describe AutoHotkey in a few sentences. However, to get a little Impression of AutoHotkey, I'll present some of the scripts I have programmed for myself:
New folder.ahk sets the Key-Combination Ctrl-N as a Hotkey to create a new folder.
Ruler.ahk switches on a reading help, by pressing the Caps-Lock-Key twice in a row. It produces a thin horizontal line that moves up and down on the Screen in response to your movement of the Mouse Cursor.
LikeDirkey.ahk sets the key combinations Ctrl-0 to Ctrl-9 for opening directories from the Explorer or dialogs.
Eject.ahk opens and closes the CD tray on key press Like on Mac OS X and shows a corresponding symbol on the screen, which fades out after a while.
And QCD.ahk allows you to change into a directory whose location is unknown or whose name you know only partially.

Eject.ahk	QCD.ahk

The source-code of these and some other scripts are available at ctmagazin.de.
AutoHotkey v1.0.22 was part of the c't software collection in issue 24/04. But you should always get the latest version, otherwise some examples will not work correctly; the author Chris Mallett
is constantly extending the performance range.
On editorials deadline, v1.0.24 had been the latest version.
You can find all the download addresses at the end of the article in chapter: Soft-Links.
AutoHotkey is installed within a few seconds. If you like to launch files by mouse later, you should take care about this during installation (activate checkbox: "Enable drag & drop onto scripts").
On first start-up, AutoHotkey is asking, whether it shall create the file "Autohotkey.ini". It's safe to allow this, afterwards the file gets opened in Notepad.
For the time being, changes aren't necessary, you can just close it.
Now a small green H icon is placed in the System Tray. You can reach the necessary tool options by its context menu.
For working more efficiently you should create a working-directory for AutoHotkey scripts and set its path to the PATH environmental variable (configuration/system control/system/extended/environmental
variables; edit the "PATH" entry and add the directories path at the end). Now you may reach your scripts via start/execute.
To create a new script: Move to your working-directory, right click and choose new/AutoHotkey Script and rename it with a *.ahk as extension.
Such files with *.ahk are connected with AutoHotkey and can be open and loaded immediately by double clicking them.
In this case, nothing will happen because the script doesn't contain any command.
By selecting "Edit script" in the context menu, the script is opened in Notepad exactly like every other script.


Those
who prefer a more comfortable editor will find some syntax highlighting scripts for some well-known editors in the folder Extras/Editors within the AutoHotkey directory. Even an automatic installation script is ready for MED,TextPad and EditPlus.
The colour syntax highlight makes getting started with AutoHotkey much easier because one can see whether a command was written wrong. However, those who don't like to work with notepad and
who lack one of the supported editors may change the standard editor for editing scripts by drag n' drop it onto my script: "change standard editor.ahk", which is a component of the download package mentioned above. It changes the menu instruction "Edit script"
correspondingly.

Hotstrings

One of the core functions of AutoHotkey is working with text modules.
These "Hotstrings" react to defined key combinations the user enters in a program of his/her choice or in one the developer defined. So abbreviations are easily converted to the extended form.
The key combination is placed between 2 colons each, and is followed by text that should be substituted in place of the abbreviation. You may enter the lines of the following example into a
script file and then execute it by double-click.
After that the script is interpreted and executed by AutoHotkey.

::wkr::With kind regards{Enter}{Enter}

The greeting phrase is inserted automatically as soon as the key combination "wkr" is typed in an arbitrary program and followed by a final character, which may be the return key, a comma or
a space. Within the definition, more parameters can be used. For example the letter "o" between the first two colons prevents the final character from being sent to the program.
Within a few minutes a professional writer can create an individual collection of text modules without which he soon wouldn't enjoy working anymore.

Step by Step to the first Script

However, AutoHotkey scripts are far more than the collection of key combinations. With the over 200 instructions, utilities can be programmed for which a fully-grown software development kit
would otherwise be needed (along with a much greater expenditure of time).
Although the AutoHotkey script language isn't by far as powerfully as Delphi, Visual Basic & Co. but for most automating tasks it is completely sufficient.
The dialect is similar to BASIC, and therefore easily to learn. Each instruction with its parameters is written in a line of its own.
To increase the clarity, you may indent scripts with tabs or spaces arbitrarily, which for example is suitable for loops. Parameters are separated from the instruction and by other parameters,
with few exceptions, by commas. Even though AutoHotkey ignores the case of variables, instructions and sub-routine identifiers, it is advisable to maintain consistency with a notation of your choice. For example, I have become accustomed to writing instructions
with their first letter capitalized.
Make sure to comment your scripts. A comment is started with a semicolon such as in the following quite practical script, which assigns a key combination to a function:

; Windows-Key+i
#i::
Run, iexplore.exe
Return

By the two colons at the end of the second line, AutoHotkey recognizes that it shall process a combination of keys. The pound sign symbol stands for the Windows key, followed by the letter
for the other key, in this case the I key. The instructions which shall be executed when pressing the two keys then follow. Key combinations and sub-routines, which are analogous to those of others programming languages, are finished in AutoHotkey with return.
A single colon indicates a normal sub-routine which isn't connected to a hotkey and can be jumped at with the instruction 

GoSub

.
After executing the sub-routine, the Interpreter continues the script, starting at the line after the 

GoSub

 instruction.
The instructions of a hotkey can also be invoked with 

GoSub

. Both forms of sub-routines may be distributed
arbitrarily in the script, but may not be interlocked with each other.
The command 

Run

 executes a program along
with optional parameters as if it had been entered at the Run dialog in the start menu. In the example above, Internet Explorer is launched; every other program can be launched just as well. Within the parameters of each AutoHotkey command, all leading and
final spaces are ignored. However, to improve readability of the commands, a space should be placed after every comma. (As opposed to other programming languages, text that contains spaces should not be enclosed in quotes.)

Run

 supports some more parameters. The
second parameter indicates the working directory and the third parameter states whether a program shall be started maximized, minimized or hidden. A variable name can be placed as a fourth parameter, in which the process number (ID) is will be stored. The
Web browser is started maximized with the following instruction:

Run, iexplore.exe, Max

Optional parameters are simply left empty; AutoHotkey then assumes a standard value. In this example above, Internet Explorer isn't executed in a special working directory but instead in the
working directory of the script itself.
Since hotkeys frequently include only a single command, there is also a simplified notation for this, where everything is contained on one line and the 

return

 isn't
needed, allowing a clearer arrangement:

#i::Run, iexplore.exe ; Win-i
#g::Run, http://www.google.de ; Win-g
; and so on, and so on ...

Run

 is limited not only programs but also
URLs and documents, which are then opened with the associated application in Windows. Next to conventional keys on the keyboard, mouse actions can also be captured and assigned to functions. The practical mouse wheel, found on most modern mice, can be used
fantastically e.g. for a small script which system-wide varies the volume:

; Win+MouseWheel forward: Louder
#WheelUp::SoundSet, +1
; Win+MouseWheel backward: Lower
#WheelDown::SoundSet, -1
; Win+Numpad0: Volume on/off
#Numpad0::SoundSet, +1,, mute

The semicolon'd comments above again explain what exactly happens, and the pound sign symbol is used again: 

#WheelUp

 reacts
if the mouse wheel is rolled up or forward while the Windows key is held down; 

#WheelDown

 behaves similarly
when the wheel is rolled in the reversed direction; and 

#Numpad0

 switches the sound output completely on
or off again if the key combination Windows-0 (on the number pad) is pushed. The other modifier keys have symbols of their own: the Alt-key is equal to 

!

,
the Ctrl-key to 

^

 and Shift to 

+

.
To distinguish between the left and the right key, a 

<

 or 

>

 is
put in front of them. Finally, 

SoundSet

 is used to vary the volume in the indicated steps.

Completely variable

With variables, scripts get flexible. Besides predefined environmental variables and script properties, which can be used as a parameters for commands e.g. 

A_ComputerName

 or 

A_ScreenWidth

,
you may define your own variables, which is similar in conventional to Batch files: 

Variable_name = [contents]

.
Variables are always global, so they are available to all sub-routines and hotkeys throughout the script. Their names may consist of letters, numbers and the characters 

#

, 

_

, 

@

, 

$

, 

?

, 

[

 and 

]

.
A variable is automatically a string, e.g. with text contents (

name = heise

). To work with numeric variable,
simply assign numbers (

x = 30

), AutoHotkey recognizes this automatically. Mathematical computations are still
a little limited and require repetition at present: For each calculation, a separate command must be used, e.g.

Variable = 9
EnvAdd, Variable, 4
EnvMult, Variable, 3

To references a variable, e.g. process its content, enclose its name within percent signs: 

MsgBox,
%variable%

. Like in other languages, there are also commands to manipulate variables of course, for example StringLower which converts a string to lower case letters.
With the help of variables, example script 1 copies the word currently selected on the screen onto the clipboard and transmits
it to the online translator leo.org – the dictionary is ready at the touch of a button. Beforehand, the previous contents of the clipboard get buffered (

tmp
= %Clipboard%

) and restored again later (

Clipboard = %tmp%

). However, 

Clipboard

 is
a system variable that can only handle texts. So another data type on the clipboard, e.g. a picture or a tone, is lost by the execution of this script. [Update: The

ClipboardAll

 variable
was recently added to avoid this limitation.]

Remote control

The simplest way to automate the system or an application involves the 

send

 command
to transmit keystrokes to these. It transmits the keystrokes as if the user had typed them manually. The 

send

 command
also plays an important role in the example just mentioned: It is used to imitate the key combination Ctrl-C for copying the highlighted word onto the clipboard. Since that key combination is recognized by nearly all Windows programs, the script's operation
is independent of the program currently in foreground: Word processing, appointment book or spreadsheet analysis.
However, to execute a keyboard combination or a script only for a certain program, at first one must check whether that program is active. The following example provides a function for Internet
Explorer to show the source text of a web page, which relies on the fact that Microsoft has not yet assigned Alt-F3 to any function. The script achieves this by "pressing" the Alt-key (menu call), the A key (menu view) and the Q key (for source text) one after
the other: (A and Q are for German keyboard layout):

~!F3::
ifWinActive, ahk_class IEFrame
{
Send, !aq
}
Return

The tilde (

~

) at the start of the keyboard
combination Alt-F3 means that this is not intercepted but passed through, which prevents programs that already use Alt-F3 from stumbling. 

IfWinActive

 checks
the name of the window class (ahk_class), which was previously discovered with the help of the "Window Spy" function in the Tray menu of AutoHotkey: By Shift-Alt-Tab for example one changes to the desired window to also learn from it the title, the position
or the X and Y coordinates of the mouse pointer. To transmit a key combination not only to a window but to a determined part of a window, which is e.g. an entry field or a button (a "Control"), the command 

ControlSend

 can
be used. A script which demonstrates the command in the interplay with the FTP client FileZilla is contained in the download package.

File system and registry

AutoHotkey cannot only manipulate programs but also windows, files and even the registry database. Example 2 deletes all
files from the cache of the Internet Explorer, more exactly from the directory "Temporary Internet files" which are older than a week. Of course such a script could be assigned to a hotkey; however it is even better to put it in a separate script file which
is invoked at every system start.
RegRead reads a value from the Registry – in this case, the path of the directory – and stores it in the variable 

tempInternetFiles

.
The script then passes through a loop in which the second parameter (0) means that only files shall be checked and the third one (1) defines that also files from the subdirectories are taken into account. The subtracting command 

EnvSub

 determines
the age of the each file by deducting from the date 

today = %A_Now%

 (system variable) the date of the last
modification 

A_LoopFileTimeModified

. The command

FileDelete

 within
the If block finally deletes each file that is older than seven days. Blocks and loops start with 

{

 and end
with 

}

.

Niceties

While AutoHotkey usually terminates scripts after the last instruction is executed, scripts which wait for a key combination or a key sequence remain permanent in memory. To grant this status
to other scripts as well, simply insert a line at the beginning of the file with the contents #Persistent; if necessary, one can then terminate the script by specifying ExitApp. It should always be remembered that after changing a script – whether persistent
or not – it has to be reloaded into memory, since otherwise it will continue to run with the old settings. One can take care of this by either double-click in Explorer or selecting the context menu instruction "Reload script". It's more comfortable to insert
a routine in the script which automatically reloads it after every modification, see example 3. This is especially and enormously helpful during the programming and testing stage. Each loaded
script is started as an independent process, which can be seen as an additional icon in the System Tray. Since each running script uses approximately between 2 and 3 MByte of working memory, where possible you should combine scripts that are supposed to be
permanently active into one to save memory.
With a right click on its icon in the System Tray, the context menu of a script gets opened. In this context menu the script can be ended, edited, paused or stopped for a short time from processing
keyboard combinations ("Suspend Hotkeys"). The instruction "Open" or a double-click on the icon fetches the real program interface of AutoHotkey to the foreground. In the view menu one can retrieve rather a lot useful information, which are very helpful for
bug searching within a script, e.g. the last executed instructions, all variables and their contents, assigned keyboard combinations, as well as a list of the most recently pushed keys.


To
save the annoying work of typing scripts, you can use AutoScriptWriter, which is included with AutoHotkey. It records all actions and puts them into the script language. It is an especially indispensable too for determining mouse positions. You will notice,
though, that a script created by a recorder can seldom be used as-is; a little polishing is always necessary.

Drag, Drop & Exe

Parameters can be submitted to scripts on the command line or by Drag & Drop if the option was activated at installation.
The individual parameters are stored in the variables 

%1%

, 

%2%

, 

%3%

 and
so on. The total number of incoming parameters is put into 

%0%

. The following example copies all file names
of a submitted directory onto the clipboard, which might be useful to print the contents of a freshly burned backup CD for its cover.
Copy this into a new script file:

SetWorkingDir, %1%
Loop, *.*, 1, 1
{
All = %All%%A_LoopFileFullPath%`r`n
}
Clipboard = %All%

If you drag and drop the icon of a folder onto the script, the folder's path (which is in the variable 

%1%

)
is submitted directly to the 

Loop

 command – with the supplemented wild card *.*, which causes all files in
the folder to be processed.
The two parameters that follow the *.* parameter specify that the script should include files in all subdirectories as well as the names of the subdirectories themselves. In the next line,
each found file name is added to the variable 

All

, along with a newline character (

`r`n

).
At the end of the loop, the script copies the contents of the variable 

All

 onto the clipboard. Within the
download package, you can find a more elaborate version of this script that integrates itself automatically into the context menu and is therefore always available.
By their very nature, compiled scripts (*.exe) always allow Drag & Drop. So by selecting "Compile script" in the context menu of a .ahk file, an EXE program is created, which can operate independently
(without the need for AutoHotkey). A speed advantage isn't gained by compilation, however, since AutoHotkey converts each script to a fast executable Pseudo code upon launch.
Compiled scripts remain pleasantly small. The mentioned directory list coverts to approximately 180 Kbytes of disk space as an executable.

Pretty Outside

With AutoHotkey, attractive interfaces can be created for scripts. A set of commands allows dealing with standard dialogs. The example
script 4 shows what one might look like. It imitates the 

run

 command shown in the Windows start menu.
Initially it displays an input box in a 240 x 110 pixel sized dialog field to prompt the user for an instruction to be run. If the user doesn't answer within ten seconds, the dialog is closed
and the variable 

ErrorLevel

 is set to the value 2.
However, if the user clicks on "OK" or pushes Enter the 

ErrorLevel

 gets
the value 0. An 

If

 statement checks the user's input by examining the contents of the submitted variable.
If it isn't empty, a 

MsgBox

 asks the user for confirmation. Only if this is answered with "yes" (

ErrorLevel
= 0

) will the script execute the entered instruction. The many commas for input box are unused command parameters; for example, with them it's possible to create a password field whose input is masked (hidden).


The 

Gui

 command
offers much more powerful and flexible possibilities. However, it would exceed the scope of this article to describe it. Nevertheless it's worthwhile to experiment with it when someday the prefabricated window command shouldn't suffice. Designing Gui interfaces
is usefully supported by the also-free tool SmartGUI Creator[1].
The detailed help always delivers valuable details about all AutoHotkey commands and parameters, and kind support can be found in the Internet forum [2].
In his "Showcase" [3] the author provides some interesting scripts, which may reveal many tricks by looking at them – for example: one displays an On-Screen display for the volume if it's changed
and another "rolls up" a window except for its title bar. Interested users will find a script under [4] that is enormously helpful when programming with AutoHotkey: It displays tool tips to guide
you while you're typing commands, regardless of which text editor you're using.
In conclusion, I would like to mention the excellent support of the author. Only a few days after I had expressed some suggestions for improvement in the forum, an updated version in which
the wishes were realized was ready. Some bugs were even removed on the same day. Such exemplary behaviour is seldom, and particularly pleasant for free software.