VBScript Scripting Techniques > HTAs

• Introduction
• Building Your HTA
• Adding Controls
• Global Variables
• Demo Project: My First HTML Application
• HTA's Path
• Command Line Arguments
• Close the HTA
• Resize the HTA
• Get the HTA Window's Dimensions
• Center the HTA on Screen
• Minimize or Maximize the HTA
• Improve Loading Speed With MultiThreading
• Embedding Images
• Embed an Icon
• Get the HTA's Process ID
• HTA Quirks and Restrictions
• VBSEdit Limitations
• Debugging
• Clean Up Your Code
• HTA Related Links

HTAs

HTAs (HTML Applications) are webpages (forms), with access to local resources.

Though the engine that executes HTAs (MSHTA.EXE) shares a lot of code with Internet Explorer, it doesn't have Internet Explorer's tight security restrictions.
In fact, if run with elevated privileges, HTAs have access to every resource that administrators have access to!

If you want to build a nice looking user interface for your VBScript scripts collection, try an HTA (or rewrite them in Visual Basic).
If you need to build a proof of concept for a new program, consider an HTA.

On this page, I intend to show some of the pitfalls I encountered in building HTAs, and some solutions or work-arounds.

My preferred tool for developing HTAs is VBSEdit. It used to come with a separate program HTAEdit in a single package, but recently these programs have been merged, and the new VBSEdit now handles HTAs too.

VBSEdit comes with a built-in debugger, but debugging an HTA is much harder then debugging VBScript code, so I usually write and test VBScript code in VBSEdit, and when ready, use it in an HTA's subroutines.

HTAs aren't restricted to HTML and VBScript, you can use JScript and JavaScript without the need to install anything, and PerlScript if you install Perl.

<input type="button" value="Click Me" onclick="vbscript:MsgBox 'Click Me (VBScript)'" />

<input type="button" value="No, Me" onclick="javascript:alert('No, Me (JavaScript)');" />

Back to the top of this page . . .

Building Your HTA

Each HTA is actually an HTML page with one or more HTA specific code blocks.

Back to the top of this page . . .

Adding Controls

In an HTA, you can add elements and controls just like you would in a web form.

You can reference an element directly by its ID, e.g. if you have a textbox with ID "MyTextBox" you can read its value with the following code:

strText = MyTextBox.value

Or:

strText = document.getElementById( "MyTextBox" ).value

The latter is much easier to debug in VBSEdit.

Back to the top of this page . . .

Global Variables

Using local variables inside subroutines is a piece of cake.
Global variables in HTAs, on the other hand, require some extra attention.

• Start the VBScript code block wit the declaration of all global variables (Dim statements) and all constants (Const statements).
• I recommend using a variable naming convention that clearly shows whether a variable is global or local.
  I use 3 letter prefixes for all variables in my VBScript scripts, e.g. strVar for strings, objVar for objects, arrVar for arrays...
  In HTAs, however, I use those prefixes for local variables only, and use prefixes starting with gv for global variables, e.g. gvsVar for strings, gvoVar for objects, gvaVar for arrays...
  This is not required, you are even free to use no prefixes at all, but these naming conventions do make debugging a lot easier.
• Though not recommended, you could choose to set a global variable right after declaring it, e.g.

  Dim gvoFSO
  Set gvoFSO = CreateObject( "Scripting.FileSystemObject" )

• The recommended way, however, is to declare the global variable at the top of the VBScript code block, and set it in the window_onload (or any other) subroutine.
• Setting a global variable using a subroutine (or setting a Control property) should be done in the window_onload subroutine, which is executed after the entire HTA window is loaded.
  MSHTA.EXE reads the entire VBScript code block linearly, from top to bottom, loading subroutines and executing non-subroutine code immediately.
  Once the entire HTA is loaded, it executes the window_onload subroutine.
  MSHTA.EXE cannot execute subroutines it hasn't read and loaded yet; likewise, it cannot set a property of a control, as these have not been created yet.

Demo Project: My First HTML Application

For this demo, we will create an HTA that accepts a number as input, and then checks if it is a prime number.

Yes, if you are new to HTAs, the following code might look rather overwhelming.
Don't worry, I will explain most of it.
And you don't have to retype the code, it can be downloaded here.

Explanation:

As mentioned earlier, the HTA starts with an HTML like head.
Specifying a DocType (line 1) is optional, but it may help getting more predictable results when running the HTA in different Windows versions.
Unlike "true" web pages, you don't have to include a <title> tag here, you can set it later, on-the-fly, which is demonstrated in the Window_OnLoad subroutine, on line 61.

In the head we also find the mandatory <HTA:APPLICATION> tag (lines 6..10); Copy and paste it from this page or from any other HTA and use Microsoft's HTML Applications Reference to add or modify its properties.

Just for the sake of demonstration, I also included an optional stylesheet (lines 12..20).

The body (lines 65..75) contains 3 main elements:

1. A textbox (line 67, ID InputNumber) to enter the number in; note that HTML 5's type="number" is ignored in HTAs, that is why we call the ValidateInput subroutine using the onchange and onkeyup event handlers.
2. A button (line 69) that will call the CheckIfPrime subroutine when clicked.
3. A text paragraph (line 73, ID OutputResult) that can be modified on-the-fly.

Between the head and the body we have a (VBScript) code block (lines 23..63).
Option Explicit (line 24) is optional, but you really should include this, if only for debugging purposes.

Subroutine CheckIfPrime( ) (lines 26..40) is the main program, checking the number and returning the result.
It reads the entered number using the code in line 28:

intInput = document.getElementById( "InputNumber" ).value

There is no need to check if the input actually is a positive integer, since validation is already handled by the ValidateInput( ) helper subroutine.
After checking if the number is a prime number, the result has to be presented (lines 30, 34 & 38):

document.getElementById( "OutputResult" ).innerHTML = "Yes, " & intInput & " is a prime number."

This will replace the text in the ouput text paragraph (line 73, ID OutputResult).

Subroutine ValidateInput( ) (lines 42..57) is a helper subroutine, filtering out everything from the input but numbers.
It is triggered when the content of the textbox (line 67, ID InputNumber) is changed (onchange event handler, i.e. on change of typed input, but also when new input is pasted from the clipboard) or when a key is pressed (onkeyup event handler).
The code in line 44 reads the input just like the CheckIfPrime( ) does.
The subroutine then uses a regular expression to remove everything but numbers (line 49).
The code in line 50 writes the corrected input back into the textbox.
The code in lines 51 and 54 changes the output text from result to description.

Subroutine Sub Window_OnLoad (lines 59..62) is executed when the HTA is loaded.
In our demo it resizes the HTA's window (line 60) and sets the HTA's title (line 61).

Investigate the demo script, play with it, e.g. change the presentation of the results, or try making it accept hexadecimal numbers, or trigger CheckIfPrime( ) when pressing the Enter key . . .
Whatever you like.

Back to the top of this page . . .

HTA's Path

Getting the full path to the HTA is easy:

strHTAPath = Self.location.pathname

Back to the top of this page . . .

Command Line Arguments

Handling command line arguments in HTAs is not as sophisticated as it is in "pure" VBScript, but it is "doable".

You can read the command line as a property of the HTA, so you need to use the HTA's ID:

strCommandLine = MY_HTA_ID.CommandLine

where MY_HTA_ID is the HTA's ID as defined in the HTA's head.

The string returned as command line starts with the HTA's full path, followed by the command line arguments, if any.
The HTA's path may be in doublequotes.

To get the command line arguments only you could use the following code:

If Left( MY_HTA_ID.CommandLine, 1 ) = """" Then
	strCommandLineArguments = Trim( Mid( MY_HTA_ID.CommandLine, Len( Self.location.pathname ) + 3 ) )
Else
	strCommandLineArguments = Trim( Mid( MY_HTA_ID.CommandLine, Len( Self.location.pathname ) + 1 ) )
End If

Back to the top of this page . . .

Close the HTA

Closing the HTA is simple, use either:

Self.close

or:

window.close True

I could not find documentation on the optional True argument of window.close.
I have once been told it forces the window to close, and my extemely limited testing showed that:

• it sometimes seems to do just that
• most of the times it makes no difference
• so far it never hurt

But, since VBSEdit only "recognizes" Self.close I would recommend using that.

In case you run the HTA in compatibility mode you may sometimes have to use window.close( ) (e.g. when using it in an event handler, <input type="button" value="Quit" onclick="window.close( )" /> otherwise you might get a "Self is not defined" error message)

Back to the top of this page . . .

Resize the HTA

To resize the HTA window, use the following code (e.g. in the Window_OnLoad subroutine):

window.resizeTo width, height

e.g.:

window.resizeTo 640, 480

Instead of placing the VBScript code in Window_OnLoad, you may also place it in the HTA's head as JavaScript:

<script type="text/javascript">window.resizeTo(640, 480);</script>

Back to the top of this page . . .

Get the HTA Window's Dimensions

The current width of the HTA can be obtained using the following VBScript code:

intWidth = document.body.offsetWidth

Likewise, the current height of the HTA can be obtained using:

intHeight = document.body.offsetHeight

Add a CSS style to allow measuring the window dimensions even if all content fits in the window:

body, html { width: 100%; height: 100%; }

Back to the top of this page . . .

Center the HTA on Screen

To center the HTA on screen, use the following VBScript code:

posX = CInt( ( window.screen.width  - document.body.offsetWidth  ) / 2 )
posY = CInt( ( window.screen.height - document.body.offsetHeight ) / 2 )
If posX < 0 Then posX = 0
If posY < 0 Then posY = 0
window.moveTo posX, posY

Add a CSS style to allow measuring the window dimensions even if all content fits in the window:

body, html { width: 100%; height: 100%; }

Back to the top of this page . . .

Minimize or Maximize the HTA

To make the HTA minimize its own window, place the following code between the HTA's head and its VBScript section:

<!-- This "HHCtrlMinimizeWindowObject" works together with the JavaScript function "_jsMinWin()" and -->
<!-- the hidden input "MinimizeWindow" to minimize the HTA window (use "MinimizeWindow.click" in VBScript) -->
<object id="HHCtrlMinimizeWindowObject" classid="clsid:adb880a6-d8ff-11cf-9377-00aa003b7a11">
	<param name="command" value="minimize" />
</object>

<script type="text/javascript">
function _jsMinWin( ) {
	try {
		HHCtrlMinimizeWindowObject.Click( );
	}
	catch ( err ) {
		alert( err.message );
	}
}
</script>

Place the following code in the HTA's body:

<!-- This hidden input works together with the JavaScript function "_jsMinWin()" and the object -->
<!-- "HHCtrlMinimizeWindowObject" to minimize the HTA window (e.g. use "MinimizeWindow.click" in VBScript) -->
<input type="hidden" name="MinimizeWindow" id="MinimizeWindow" onclick="javascript:_jsMinWin();" />

You can now have the HTA minimize itself using the VBScript code MinimizeWindow.click or document.getElementById( "MinimizeWindow" ).click

The code required to maximize the HTA again is very similar; place the following code between the HTA's head and its VBScript section:

<!-- This "HHCtrlMaximizeWindowObject" works together with the JavaScript function "_jsMaxWin()" and -->
<!-- the hidden input "MaximizeWindow" to maximize the HTA window (use "MaximizeWindow.click" in VBScript) -->
<object id="HHCtrlMaximizeWindowObject" classid="clsid:adb880a6-d8ff-11cf-9377-00aa003b7a11">
	<param name="command" value="maximize" />
</object>

<script type="text/javascript">
function _jsMaxWin( ) {
	try {
		HHCtrlMaximizeWindowObject.Click( );
	}
	catch ( err ) {
		alert( err.message );
	}
};
</script>

Place the following code in the HTA's body:

<!-- This hidden input works together with the JavaScript function "_jsMaxWin()" and the object -->
<!-- "HHCtrlMaximizeWindowObject" to maximize the HTA window (e.g. use "MaximizeWindow.click" in VBScript) -->
<input type="hidden" name="MaximizeWindow" id="MaximizeWindow" onclick="javascript:_jsMaxWin();" />

You can now have the HTA maximize itself using the VBScript code MaximizeWindow.click or document.getElementById( "MaximizeWindow" ).click

Back to the top of this page . . .

Improve Loading Speed With MultiThreading

When an HTA loads, it won't show its interface untill all work has been done, i.e. untill the code in the Window_OnLoad subroutine, and all other code called from there, has been executed.
From the outside, it may look like the HTA loads an empty window "frame" and then waits for several seconds before showing its inteface elements.
You can speed up the loading of the interface by only executing the code to build the interface in the Window_OnLoad subroutine, and then start a new thread to initialize the "background" code.

Starting a new thread is not that complicated:

window.setTimeout "subroutine", 1000, "VBScript"

This will start subroutine after a 1 second (1000 milliseconds) delay, allowing the HTA enough time to render its interface before continuing.

The first argument for window.setTimeout, the command or subroutine to be started, may have some arguments of its own, replacing the doublequotes on subroutines's command line by singlequotes, e.g.:

window.setTimeout "MsgBox 'This MsgBox was started in a separate thread', vbOKOnly, 'Test'", 1000, "VBScript"

As you can see from the example, finding typos may be a bit harder than usual.

The third argument for window.setTimeout will be "VBScript" in most cases.
However, it also opens up a way to start a JavaScript code block, by using "JavaScript".

Back to the top of this page . . .

Embedding Images

As one might expect, it is possible to use images in HTAs with the <img src="..." /> tag.
Personally I prefer to distribute HTAs as a single file.
The good news: it is possible with inline-images.
The bad news: your HTA may become huge!

First compress your image as much as is acceptable (e.g. JPEG compression, decrease color depth, etc.).
To convert the image to a string that can be embedded in the HTA you can use base64 encoding.
Assuming you have the b64 utility from SourceFourge.net, use b64 -e image.gif image.b64 to encode the image, and embed the image like this (string marked red is the content of image.b64):

<img src="data:image/gif;base64,R0lGODlhIAAgAOYAAABbAIiwiER8RADMANbW1gCZAGaZZsXFxR3oHTrWOgCDAK60rgD0AA6dDmm+aRZmFlDBPubm5gDoACKN
Ir7mvlCeUACjAGb/ZqK0ojz4PAB1ACbUJgC1AESSRA7DDgDeAA+FD9jl2FbSVmmtab29vUS6PhqnGj62Poi2iACZAO7u7hPSE8zMzABmAN3d3VCsUHj4eH6/fqfMp1q+
WiL/In6ufh1xHXGccUzXTBqwAADuAAC9AAD/AADVAN7w3gtlC0mHSR3FHYjDiAqnAAWSBQB6AB6nHl62XpWmlQCLADfpN3WwdSJsIkSNRB/4H6fEp1DqUEH/QQicCDPM
M0mpSQDDAEmUSSKTIpWxlS1xLQBmAACwAMPqvlCkUFGyUZWwlQuiC3G/ahKlEg+MDz7JPhWvFafWp3u4ewtpCx+rH3a1dv///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAUUAGsALAAAAAAgACAAAAf/gGuCg4SFhoeIiYqLjI2Oj5CRhFwQORSSiBQlQ0NhFjOYhBQnFqVn
B0YFXiqYPjMFYAUFSwcuDrIvrI+uBWIiaQ01tWtmBWQFuY0+RwUNODAmUljDgkkJCUnJictJRFMXUA1jXwcRhFRlURtJXbqFKmHdQRlRSkRXGCzmhEJENDQrFLQjpCLG
mCQenPxDQGTCAn2GQij4wIPHAAUVWBUEkaQKg4oWFTiEeGgCB5ADilRQA6LIjo8oi3R4uO/QiCQMcjKoUqSIBQk6c/LsQIKAu0MyNHzQwVRHj6VNmVrQ0KToUUQadkjY
yrWrhAIablhtZCXJh7No0xZocYNaIxRKYtOi7VGErdtGIVps6cG3L100SO46spFkgGHDVTT8COwCk4EWhwdwaPEACUlJTwBwqFJlSwsmNEMJAlBgh4XPoUWvAVKkAIAs
qVUHAABAQNGaqkMAADJWNaEIBIz6Hk68eKhAADs=" alt="Embedded icon" title="Embedded icon" />

And this is what our example looks like:

And if you aren't convinced yet, check the properties of the demo project screenshot above . . .

Or check the source code of my Attic Numerals Converter.

Back to the top of this page . . .

Embed an Icon

Assume you have an icon d:\iconsfolder\myicon.ico that you want to use for your HTA d:\scriptsfolder\myhta.hta.
If you don't mind having the icon in a separate file, add the following code to the HTA's HTA:APPLICATION block:

ICON="D:\iconsfolder\myicon.ico"

and you're done.
Instead of an absolute path, you can use a relative path, and the easiest relative path is the HTA's parent folder.
Move the icon to the HTA's parent folder and add this code to the HTA's HTA:APPLICATION block:

ICON="myicon.ico"

If you prefer to distribute your HTA as a single self-contained file, it is possible to embed an icon (or, unfortunately, any type of binary payload, including malware), by prepending it to the HTA.
I found this trick by Emeric Nasi to embed an icon in the HTA at Sevagas.com.
Add the following code to the HTA's HTA:APPLICATION block:

ICON="#"

Then embed the icon using the following command on a CMD prompt:

COPY /B d:\iconsfolder\myicon.ico + d:\scriptsfolder\myhta.hta d:\scriptsfolder\_myhta.hta

The new HTA d:\scriptsfolder\_myhta.hta will have the icon embedded.

If you want to edit the HTA later, use the original one or remove all binary code before the <html> opening tag, as most text editors will corrupt the embedded icon.
When you are finished editing the HTA, use the same command once more to embed an icon.

Back to the top of this page . . .

Get the HTA's Process ID

Insert the following function in you HTA's VBScript block, and call MyPID( ) when you need the HTA's process ID:

Function MyPID( )
	Dim colItems, intCount, intPID, objItem, objWMIService, strQuery
	intCount =  0 ' Keeps track of the number of simultaneous instances of this HTA
	intPID   = -1
	' WMI query must be escaped, hence the replacement of single backslashes by double backslashes
	strQuery = "Select * From Win32_Process Where CommandLine Like '%" & Replace( self.location.pathname, "\", "\\" ) & "%'"
	Set objWMIService = GetObject( "winmgmts://./root/cimv2" )
	Set colItems      = objWMIService.ExecQuery( strQuery )
	For Each objItem in colItems
		intCount = intCount + 1
		intPID   = objItem.ProcessId
	Next
	Set colItems      = Nothing
	Set objWMIService = Nothing
	' Set result to -1 in case of zero or multiple simultaneous instances of this HTA
	If intCount <> 1 Then intPID = -1
	MyPID = intPID
End Function

Note that this function will return -1 if multiple instances of the same HTA are running simultaneously.

Back to the top of this page . . .

HTA Quirks and Restrictions

By default, HTAs display webpages in Compatibility View, which displays standards-mode content in IE7 Standards mode and quirks mode content in IE5 (Quirks) mode.
Rounded corners, rotated text, HTML 5's new input types, and other HTML 5 and CSS 3 features are ignored in this default mode.

The solution is to insert the following meta tag in the head of the HTA:

<meta http-equiv="x-ua-compatible" content="ie=9" />

This will enable HTML 5 and CSS 3 support in your HTA (though <input type="number" /> still seems to be ignored).

You may change content="ie=9" to content="ie=10" if you want, higher is not recommended because it introduces new serious challenges and quirks.
Some errors that may occur, and that are easy to prevent:

• window_onload is not exetuted: with content="ie=11" or content="ie=edge", VBScript code no longer seems to be recognized; either revert to content="ie=9" or convert all code to JavaScript
• Object doesn't support this property or method for HTAID.version: revert to content="ie=9"
• 'Window_OnLoad' is not defined: rename your subroutines Window_OnLoad and Window_OnUnload to window_onload and window_onunload respectively (lower case)
• 'Self' is not defined: when called directly in event handlers (e.g. onclick) make sure to use self in lower case (e.g. onclick="self.close( )")
• Other not defined errors in subroutines called by event handlers: make sure the case of the subroutine's name matches, and that the language is defined, and add parentheses (e.g. onclick="vbscript:MySubroutine( )")

Make sure you also use the proper document type declaration at the top of the HTA:

<!DOCTYPE HTML>

Note, however, that in Windows 7 (and possibly in Windows 8 too) you now need to adjust all event handlers!

E.g. the "old" code:

<input type="button" value="Check" onclick="CheckIfPrime" />

must be changed into the "new" code:

<input type="button" value="Check" onclick="vbscript:CheckIfPrime( )" />

In Windows 10 this is not required (though it won't hurt), unless you use both VBScript and JavaScript.

Back to the top of this page . . .

VBSEdit Limitations

Testing your HTAs in VBSEdit is great, much faster than having to switch from the editor to a command line or Windows Explorer and vice versa.
Keep in mind, though, that when you click the "Run" button (or hit F5), VBSEdit will open and run a copy of the HTA in a different location!

Though the order of your HTA's subroutines is not critical to run it, VBSEdit's debugger treats them rather "linearly", e.g. if a global variable/object is set in line 100 in the Window_OnLoad subroutine, and referred to in another subroutine in line 50, VBSEdit's debugger will consider the variable/object not set.
So, for debugging purposes, you may want to change the order of the subroutines, as explained in the next paragraph.

Compatibility mode is great if you want to use rounded corners, rotated text and many other CSS 3 features, but it may make debugging a challenge in VBSEdit.
Compare the error messages when clicking the "Test" button in the following demo HTA, for quirks mode and for compatibility mode.

Quirks Mode (disabled meta tag in line 4)

The following error message appears when the "Test" button is clicked:

The error message points out the exact line where the error occurred.

Compatibility Mode (enabled meta tag in line 4)

The following error message appears when the "Test" button is clicked:

Now the error message points to the line calling the subroutine that contains the error!
This gets even worse when nesting subroutines...

The work-around for this limitation is to temporarily disable compatibility mode until all VBScript code has been debugged.
Unfortunately, after enabling compatibility mode, you still have to debug all code once more, to test for compatibility issues...

Back to the top of this page . . .

Debugging

Editors like VBSEdit make debugging HTAs easier, but not quite as easy as "normal" VBScript code.

Some tips:

• All advices for debugging VBScript are valid for debugging HTAs too.
• When using global variables in HTAs, declare them at the top of the code block, set them in the window_onload subroutine, and clear objects in the window_onunload subroutine.
  Place the window_onload subroutine just below the global declarations, the window_onunload subroutine at the end of the code block, and all other subroutines in between.
  Why? Because VBSEdit's built-in debugger doesn't recognize objects in code lines after the one where they are cleared, i.e. Set object = Nothing.
• Though multithreading is quite easy in HTAs, debugging a separate thread is impossible in VBSEdit's debugger.
  So you'd better postpone using multithreading untill all debugging has been done.
• Global variables will not be shown in VBSEdit's debugger window when hitting a breakpoint in a subroutine.
  It may be useful to declare a dummy variable in the subroutine you are debugging, and then set its value to that of the global variable just before the breakpoint.

Back to the top of this page . . .

Clean Up Your Code

More, even, then "normal" VBScript code, HTA code can have some stray code left after making changes: undeclared new variables, unused variables, or even entire unused subroutines.
This will increase maintenance complexity of your HTA.

Using an editor like VBSEdit you will get warnings when trying to use undeclared variables, including typos in variable names (assuming Option Explicit is your first line of code in the VBScript block, which is highly recommended).

Use my CheckVarsVBS.exe to check for unused variables and subroutines.

Back to the top of this page . . .

HTA Related Links

• Extreme Makeover: Wrap Your Scripts Up in a GUI Interface
• Introduction to HTML Applications (HTAs)
• HTML Applications Reference
• Add a Gradient Background to Your HTAs
• Hacking around HTA files by Emeric Nasi
• My own HTA & WSC Examples
• Try Adersoft's VBSEdit, an VBScript and HTA editor with built-in debugger, IntelliSense^™ like "intelligence", COM object browser, snippets library, configurable external tools and built-in packager (HTA "compiler").

Back to the top of this page . . .