Navigating This Document

Use your heading navigation commands in jaws, h and shift+h, or the JawsKey+f6 list of headings dialog, if you want to get an overview of the content of this document.
note: The jawsKey+f6 list headings option, is very useful for quickly navigating to headings whose name is familiar, since you are able to use single or multi letter navigation within the list view, to immediately jump to headings beginning with the letters you type. navigating headings in this dialog also avoids the heading level announcements spoken by the h and shift+h keystroeks.
As you read, You may also find it useful to utilize the one shot temporary bookmark feature of jaws, control+k, before following this page links to skip to other sections of this document. pressing K or shiftK, will then provide a convenient method of returning quickly to your previous location, to recommence further reading.

Additions and Changes in build 191

terms Of Use

First, it is important to recognize that a volunteer effort like that which created HotSpotClicker simply does not have the resources to do adequate testing to assure that you can not possibly run into problems through the use of HotSpotClicker. We have gone to great lengths to try to insure that you will have success in the use of this utility. but, There are far too many possible combinations of circumstances to anticipate them all. You should create a backup of any scripts, including all associated configuration files, to which you wish to connect this utility, just in case your modifications, or inadvertent editing errors, cause undesired changes in the applicaition scripts.

Just as do Microsoft, and Freedom Scientific, and practically every software vendor in the world, I make no warrantees, implied or expressed, that these scripts will do exactly what you expect them to do, nor that unintended consequences will not result from their use. they are offered free of charge, and you use them, as is, at your own risk. Use discretion and caution, and be prudent.

These scripts are free for unlimited use, on any number of computers. You can share them freely, and you can modify them for your own use. If you wish, you can submit code modifications for consideration. If they are accepted, you'll get your name listed in the credits, if you like. You can even sell your services applying HSC for other people, and we won't even ask you for a cut of the action, though you might reasonably consider making a donation toward HSC development.

What you can not do, is sell the scripts themselves, or any derivative of them without binding agreement with Jim snowbarger (The Snowman). TheSnowman@Snowmanradio.com

Credits.

Sincere, heart-felt Thanks go to several other individuals who have played important roles in making HotSpotClicker possible.

Thanks to Geoff chapman for his invaluable support and inspiration. His relentless commitment to excellence was the impetus for many useful and creative features, and help to bring this project to fruition and make it available for free download. Geoff has also generously offered to provide frontend support to those who have problems getting this utility installed and working on their machine. you may contact him at: gch@internode.net.au

Much deserved thanks also go to Andrew Heart for providing the hscsrvr.dll, which was used to replace problematic JAWS file input/output routines, and to dramatically accelerate color searches. andrew pulled us out of a very difficult spot, and your experience will be much more rewarding, thanks to his efforts.

Greatful Thanks also goes to Jim bauer for providing the code which allows multiple, or nested, post-processing functions.

Thanks to Doug Lee, for letting us scavange his clever solution to the multiple-letter navigation problem posted by some recent versions of JAWS.

Thanks to Victor Tsaran, for his invaluable help creating the hotSpotClicker installation and uninstallation routines, using the nullsoft scriptable installer. And, ya just gotta love that endearing podcast about HSc. Ignore his advice though, and do read the documentation.

And finally, Thanks to Phil Muir for graciously hosting HotSpotClicker.org. Everybody has to live somewhere. And, Phil's house is a castle.

Now, if we can just fine an organized person, with a good command of English to rewrite the documentation, well ... then we'd be in luck.

QuickStart guide.

For you technically savvy hotshots, who already know all about computers and scripts, and just want to get up and running with a minimum amount of happy talk, we have created the quick start guide. it's language and explanations are substantially more to the point. Consequently, it assumes a medium knowledge of computers and computer concepts. By all means, click below to open this quickstart guide, as you may well find it the fastest way to learn the basics, about setting up hotSpotClicker to work with your favorite applications.
But, in order to gain the most from the HotSpotClicker tool, we strongly encourage both new, and experienced users, to come back and explore this InDepth user manual as, while being slightly more verbose than the Encyclopedia Brittanica, it does contain important Clicker concepts not present in the quickstart guide.

tip: to open this quickStart guide in a new window, enabling Alt+tab navigation between the two open documents, if using Jaws and internet explorer, when focused over the link below, instead of pressing enter, press the NumPad star, (right mouseButton emulation key.) Then, from the resultant context menu, choose, "open in new window," and press enter. Click here to open the hotspotClicker quickstart guide. skip to HotSpotClicker download and installation instructions.

Note To Developers.

If you are a script developer, and want to make your scripts HSC-ready, so users can connect HSC into your scripted application without requiring any further modification to your scripts, download the .zip file below. it contains condensed notes on how to interface HSC with your scripts, as well as a place holder jsb file to provide the null stub functions which you will need to call, and rules you will need to follow in order to make it work. Download HSCStubsForDevelopers.zip

Introduction.

From time to time, I am approached by people who are having problems in their work situations, because their employer has started using software that requires that various spots on the screen be clicked with the mouse, but jaws thinks such spots are blank. there is no graphic, or other item which JAWS can latch onto in order to reliably find the location. In some cases, these people are at risk of even losing their jobs if they can't figure out a way to overcome that relatively minor problem.

Well, it is minor if you know how to overcome it, because JAWS offers several tools within it's powerful scripting language to facilitate doing that. But, it can be a big deal indeed if you don't.

As blind computer users, we've all experienced what at best, can be very frustrating, and at worst, potentially totally debilitating situations, in which a sighted friend or coleague is immediately able to effect a necessary task in a computer application that we may've been struggling to figure out for a lengthy period of time, by simply, "just clicking over here!". now, With hotspot clicker, you can be ready when this situation occurs again!

Having Hot spot clicker on hand may simply eliminate, or significantly reduce, those incredibly frustrating situations where you may've previously been forced to await the arrival of either a blindness agency I T consultant, or for customized scripts to be released, or for the often long and drawn out process of writing to the developer of the problem application, seeking to engage their interest in providing a more keyboard friendly user interface. Which, as we've all experienced, is often a somewhat less than successful endeavor.

Many modern programs are increasingly becoming useable predominantly via the operation of the mouse, and they are becoming more and more dificult to operate effectively and productively, via the keyboard alone. They often require the mouse to be clicked at certain locations, in order to either bring focus to certain parts of the program, or to perform certain tasks. in some situations, if you can not easily find a way of efficiently navigating the mouse to those locations, you simply can not operate such programs at all.

even some applications which display their screen area labels in bit mapped text, which is completely unreadable via screen readers, with some initial sighted assistance, can often be labelled, and thus made usable through the use of hotspot clicker.

Of course, you can make jaws do a mouse click at any location you want, as long as you know where that location is. But, actually implementing a set of robust scripts to do it, complete with a speech friendly front end user interface, requires a few steps that are offten a bit daunting even to the moderately experienced scriptor. So, this free set of scripts is designed to facilitate the process, and is my gesture toward those who find themselves in situations like that, but whom I could not help at the time. It may even be of help to those who do simple scripting to adapt such software for their clients.

But please do not think that Hotspot clicker is just for people in critical work situations. basically, if you've ever found yourself as a blind person using a computer, needing to click with the mouse (or jaws cursor,, in jaws they are one in the same,) somewhere onscreen to affect a certain task, and wishing it could be done more quickly and easily than crawling tediously around with the jaws cursor looking for it, then hotspot clicker can very likely help you. For at it's most basic level, this is the primary function hotspot clicker has been designed to facilitate.

HotSpotClicker can even be used to improve the interface to programs that are already mostly keyboard accessible. It can do this by having user's define screen locations where certain mouse actions are required, or important text items you wish to "glance at" are located, and by associating such screen locations with hot keys, and/Or user defined names.
Even in applications where the controls may all be accessible via the keyboard, either through the menu system, or perhaps via multiple and thus somewhat inefficient presses of the tab key, Hotspot clicker can very often bring increased speed, efficiency, and ease of use, by being able to immediately bring focus to, or click on, those controls that you use the most, and attach operation of those controls, to easily accessible shortcut keys of your choice.

The windows Volume control application provides just one universal example of a program in which hotspot clicker can be of immediately obvious benefit in this kind of situation. Imagine being able to immediately design your own hotkeys, either to bring focus instantly to the sliders you desire to adjust most often, or perhaps to immediately click on the buttons which may either mute or select the mixer controls of most interest to you, without having to tediously tab through all of them to locate them. HotSpotClicker can help you do all that, and a great deal more.

HSC Versus Frames Manager.

At first blush, one might be tempted to think that the frames manager utility, already built into jaws, could be made to achieve some of what we've been describing. So why the need for an extra utility like the HotSpot Clicker?

It is certainly true that The JAWS Frames Manager is very powerful, and can in the hands of a capable and patient person, be used to do some of the things that the HotSpotClicker can do. In fact, frames manager can still provide some functionality that hotspot clicker currently does not. such as to monitor certain areas of an application and automatically speak text appearing there, or to silence chatty portions of an application etc.

Frames Manager certainly does have an important place an any good adaptive technologist's tool kit. However, it does have a number of very frustrating design flaws, which can make it difficult and very time consuming to use in some situations. In the next few paragraphs, we will contrast HotSpotClicker with the Frames manager in an effort to highlight some of the improvements we are attempting to make available.

The HotSpotClicker has been designed for ease of use, and has some nice advantages:

• More and Better qualified position tracking criteria, leading to a more precise validation of the target location.
  This gives you more control over determining when the location is valid, helping to prevent clicking under the wrong circumstances, but also allows you to work more effectively at the child window level, rather than being primarily limited to the larger windows with title bars understood by Frames manager.
• Identify your location relative to the edges of the current window, TopLevelWindow, Application Main Window, or the screen at large.
• There can only be one set of frames per application, with one set of application wide hotkeys to activate them.
  This can be extremely limiting if you find you need a large number of frames, in an attempt to facilitate quickly and efficiently clicking, or positioning the mouse at multiple locations across many different screens, in a particularly keyboard unfriendly application.
  but with hotspot clicker, you can have multiple sets of hot spots, one for each TopLevelWindow within an application, each having it's own unique set of hotkey assignments, which you can activate in a variety of manual ways, or which can activate automatically as the application is navigated.
• A dramatically simplified wizard-style, definition interface, which learns from your preferences, and suggests likely answers. requiring significantly less time and effort to get things up and running.
• Provides quick, efficiently navigable lists of active HotSpots, and hot spot sets.
  
• An additional, "spot prompter," feature, for those situations where you tab to a control, but jaws does not speak the correct label. In certain situations, this feature can provide significantly enhanced functionality and reliability, with less custom configuration, over the built in jaws "prompt creator."
• The ability to far more easily and quickly locate and edit all aspects of the hotspots or prompts, directly from within the application itself.
• Provides better debug information to help you decide why your hot spot may not be functioning as expected.
• the ability for hotspots to dynamically relocate their positions based on user definable text, graphics, or color search criteria.
  This increases the likelyhood that the correct spot can be accessed without having to redefine a brand new frame for every location the item of interest may occupy, in a dynamic appplication environment.
• And, you can integrate the HSC with your scripts, use our positioning engine to find your location and perform the requested mouse action, and then automatically run your own function to evaluate the results, or take further action.

What Can I Do with this thing?

Oh boy! Get Ready, because there is a bunch of stuff.
With Hotspot Clicker, You are able to:

• Define special hot keys which, when pressed, can:
  
  • perform a particular kind of mouse action at the desired location, such as any kind of left/right mouse click, with, or without keyboard modifiers. including lock, or unlock, mouse actions. In addition, special custom time delay mouse click actions can also be chosen, which can effectively be used to work around situations where using the normal jaws mouse click emulation keys, simply does not effect the same results as clicking the actual physical mouse buttons.
    These custom click actions can also be used to force the mouse to hover for a specifiable time at the spot before clicking, to give the program any necessary time to bring about certain results through the process of mouse over hovering, before the click action is performed.
  • speak information such as a chunk of text, a field, a single word or labelled graphic, at a given location.
  • run a user supplied function from your script file, or one of several supplied functions, either before or after the mouse click has been performed, to help either track a, "moving target," hotspot, or to confirm that the desired response from the appplication has taken place; For example: track a preLabelled graphic within a window, click it with the mouse, and speak it's resultant post click status.
  • Just Take the mouse instantly to a given location, perhaps in order to drag a slider or adjust a graphical knob, or to cause certain desired events to occur, such as bringing up a menu or triggering a sound to play etc, from applications which will only render such responses from the mouse hovering at key locations.
    this may also be of benefit simply to confirm that the desired click zone, is still located at the initially defined hotspot location.
  • speak a color-specific string of text based on the color at the hotspot location.
  • Run a color-specific custom function from your script file, depending on the color found at the hotSpot location.
  • Set focus on a certain control or window.
  • Activate a different hot spot set.
• All HotSpots, as well as HSC master keys, show up in the jaws keyboard help mode, enabled with the JAWSKey+1 combination. This can be very helpful for quickly verifying which hotspot maybe assigned to a given key combination in the currently active set, or in any other hotspot sets in which the key combination has been assigned within the current application.
• You can also activate these user defined HotSpots in two other alternate ways, other than using their user customizable hotkeys:
  A.) you can bring up an alphabetically arranged list of the defined hotspots, and either arrow through them, or press the first letter(s) of their names to jump focus immediately to them, and press enter to activate them.
  This can be helpful in situations where you might not be able to easily recall a hotSpot's assigned hotkey, or to activate less often needed hotspots for which you would prefer not to have to use valuable hotkey real estate.
  B.) you can also choose certain favorite Hotspots, and construct these in whatever custom order you like, into what we call a "spot ring." This facilitates being able to more directly and conveniently, "tab," around your ring of hotspots, effectively giving you the power to construct your own mouse click keyboard driven custom tab order.
  SpotRing navigation can either be left assigned to the built in hsc keystrokes of altControlTab to move forward, and AltControlShiftTab to move backwards, or, where oneHanded SpotRing navigation is desired, can also be mapped to the more convenient Tab and shiftTab keys, with the ability to easily toggle this functionality On/Off, to quickly return these keys to their standard application functions.
  In addition, you can choose on the fly whether or not you would like your, "spot ring," to, "track," along with your keyboard activated hotspots. This enables you to choose to replicate the more standard functionality, of having your spotRing tab order focus, track to the current position of whatever Hotkey you may've last executed for spots within the spotRing, or alternatively, to remain fixed at a given position in the spotRing as a kind of secondary bookmark, or place holder. In this mode, you can activate any other hotspots without effecting the current SpotRing position.
• HotSpots can be, "chained," together, effectively creating the ability to construct a set of multiple macro like instructions which should be executed at the press of a single hotkey. One example of This powerful feature, might be to set up preDetermined hotspots for previously keyboard inaccessible Drag and drop operations, and chain them together. Such that by pressing a single hotkey, the mouse moves to a predefined hotspot, locks the left mouse Button there, then immediately jumps to a second predefined hotspot, and releases the mouse button to drop an object at the new location.
• You can even have different hot key assignments for different portions of your application, and, if you like, have them be automatically activated as you move from one area to the next.
• A, "Spot Prompter," feature, for those controls whose names and values are not correctly spoken as they gain focus. You can specify a label to be spoken for certain types of controls within the hotspot clicker environment, plus the ability to set a custom function to better handle the problem control or field that is not providing adequate information using jaws default processing. In addition, you can specify a custom string that can be spoken after processing has taken place, along with an additional tutorial message if desired, and even activate a different hotspot, or chain of hot spots, to speak information located elsewhere on the screen when the item of interest gains focus.
  for example, suppose you tab to a control whose value is spoken, but no clue is provided either to indicate the purpose of the field, or what the value is actually measuring.
  In many of these situations, Spot prompter allows you to assign both a custom label to identify the purpose of the control, and a string that can be spoken after the value of the control has been announced, to provide more intuitive feedback about the control.
  Or, suppose you have a slider control, which can be operated by the arrow keys, but whose value is also displayed in an edit field elsewhere on the screen, but is not being read out by jaws. You can set up a hotspot on the edit control, and set up a spot prompt on the slider, and chain the two together, such that, when the slider gains focus, jaws will announce the purpose of the slider, and then read out the value in the edit field.
• HotSpots can be tied to the existence of specific text strings, or graphic labels, including background and foreground colors, and optionally dynamically track and relocate to new spots, through various text, graphic, and color search options.
• PC cursor relative positioning modes, - Your hot spot can follow your PC cursor, staying a fixed distance vertically or horizontally from the PC cursor.
• A dedicated "move to spot," hotkey, which exclusively permits positioning of the jaws cursor at any of the defined hotspots in the currently active set, no matter what click action the spot may be programmed to perform. This is convenient for manually checking the location of a hotspot, to see if the desired information still resides at the initial location.
• The ability to assign one of a range of builtIn, or user created custom functions, which will run after the main hotspot action has been performed.
  This capability allows you to select from a list of builtin post-action capabilities, as well as the ability to write your own custom function in your application script file, and add it to the list for selection when defining additional hotspots.
  An example of functionality provided by just one of the HSC-supplied builtin functions, is the ability to have a custom function executed, or a user definable text string spoken upon the discovery of a certain color,, at a given hotspot, after the mouse click has been performed. Whether that spot is part of a graphic or word, or not. i.e. areas of the screen that appear totally blank to jaws, can be labelled with hotSpot clicker. Thus providing the ability to create a navigable accessible hsc text based interface, for an application whose interface may otherwise consist exclusively, or partially, of BitMap image labels totally invisible to screen readers.
• Define certain mouse only opperable vertical or horrizontal sliders, in a given hotspot range of travel, such that by the press of a single hotkey:
  
  • the mouse can actually track the position of the slider within it's predefined range, and locate itself directly on top of it for further manual movement;
  • the actual position of the slider within it's specified range can simultaneously be spoken, in user definable units of measure, that are meaningful to the purpose of the control. e.g. milliseconds, DB, percent, Semitones, etc. This gives the blind user, a similar ability to, "glance," at the general position of a non-keyboard opperable slider, and have it's position reported in a meaningful way.
• an additional expanded hotspot assignment wizard allows for the defining of a particular previously Labelled graphic, or set of graphics, text strings, or a certain RGB color, which can be automatically searched for and clicked on if located. either within a small user definable sized area around the initial hotspot location, or within the window in which the hotspot was defined, whether it be the child window, the topLevelwindow, or the application main window. Window Searches can also be set to commence from either the top, or bottom, of the window, and for Text and graphic label strings, some enumeration support is included. Though it must be pointed out that the practical reliability of being able to locate x of Y strings in a window, can be largely effected by a number of dynamic environmental factors out of our control, not the least of which is jaws somewhat tenuous and variable consistency in rendering of the Off Screen model. IN applications where the graphics prove reliably and consistently detectable with jaws, (which, please do be aware, is certainly not all of them,) this can facilitate operation of a particular graphical tool or button, which may alter it's position too often to be useful for one given hotspot location, and which may change it's label depending on what state it is reflecting.
  Combined with the SayWord post processing custom function, this can be a very powerful feature, allowing for the toggling of a graphical button, and the hearing of it's altered state as it is toggled, no matter where it may move within the Window.
• Search/feel around within a small user definable area, for a particular color, or list of colors, which uniquely identifies a particularly troublesome click location, that just won't quite stay put! If the color cannot be located, the click will not be performed.
• To aid in hotspot definition, a special set of hotkeys allows you to move the mouse in small increments in order to ascertain the color of a given pixel manually, to help identify the particular colored pixel, that actually changes in response to a mouse click, before settling on the exact spot to define for the click action.
  This is important because, while the sighted person is looking at the mouse cursor, which is large enough to occupy a physical screen area encompassing several pixels, the HSC is looking at a single individual pixel, and it is important to assure that that single pixel is the one which changes color when the mouse click occurs, so that an appropriate event may be slated to take place upon detection of specific colors at the hotspot location. This is most commonly a spoken text string or label, but can be assigned to several other post click functions as well, including the automatic activation of another Hotspot.
• All aspects of any hotspot definition, including it's key assignment, or hotspot label, can be quickly and easily edited directly from within the working application, using the hotspot definition editor.
• The ability to customize the Hotspot clicker's master key assignments if desired, through editing of the, "HotSpotClickerKeys.jsh", file, and recompiling the script source.
• Special mouse position and movement utilities, useful in learning how an application works, allow you to:
  A.) explore individual pixel colors, either manually, or automatically announced as the alt+shift+arrow mouse movement keys are executed. In color or Graphic automatic announcement mode, (separately switchable,) a Beep will signal when the color has altered, allowing you to momentarily slow mouse navigation in order to hear the new color currently visible under the mouse.
  B.) be more directly informed of either the absolute, or window relative, x y pixel position of the mouse, through pressing the hsc hotkey of altShiftDelete. Once to hear Absolute, and twice to hear selectable window relative coordinates. This is rather convenient as you can continue to hold down the alt and shift keys whilst moving the mouse with the arrow keys, then simply tap the delete key to check the current pixel location.
  C.) Whilst exploring the screen with either the jaws or invisible cursors, you have the ability to set a one shot bookmark with altShiftPageUp, then continue exploration, and return to that bookmark at any time with altShiftPageDown.
  D.) Bring up an edit box into which you can type a set of coordinates, either relative to the the edges of the screen, or of a particular window. This is convenient if another user of an application which you may be trying to navigate, informs you of a particular set of x y coordinates that when clicked on, performs a particular function, and you then wish to make your own hotspot without any sighted assistance, at this location.
  
• Automatically scan your application, or a particular window, for ToolTips, and create hotspots from any, or all, of the toolTips that were discovered.
• Define a group of hotspots in the current set, and specify that they should all be relocated to new positions, based on a global set of offset values. This is a very convenient way to correct the positions of multiple hotspots.
• You can view the recent spoken HSC message history in the virtual viewer.
• Some HSC option controls are automatically added to the JAWSKey+v verbosity menu.
• Replicate a HotSpot. Suppose your application has an array of 16 vertical sliders, all equally spaced on the screen. This feature would allow you to define and fully test a hotspot for the first slider, then place the mouse on the last slider in the series, and command HSC to automatically create 15 additional hotspots, just like the first, but positioned appropriately to address the remaining sliders. This feature also includes an undo feature.

Installation and connection of the hotSpotClicker.

For complete instructions upon uninstalling hsc from your system, please see: how to uninstall HotSpotClicker

Installing HotSpotClicker.

Click below to download hotSpotClicker build 192
Download Hot Spot Clicker executable installer. When requested, Choose the save option from the internet explorer download dialog. Take note of the "save in," field, in order to more easily relocate the file once downloaded.

Once the file has completed downloading, navigate to the file, and press enter. The hsc installer program will open.
Carefully follow the on-screen instructions.
General tip: if at any stage during a software installation, you find that jaws fails to read any dialog automatically, in order to be fully informed at each step of the process, it is suggested either to:
A.) use Jawskey+NumPad minus to route the jaws to the pc cursor, and press control+Home to move the jaws cursor to the top of the window. Then explore the screen manually. or,
B.) use JawsKey+b, to have jaws attempt to more automatically speak the contents of the dialog box for you.

Several enhancements and changes have been incorporated into this new hsc installation program. For those familiar with the previous hotSpotClicker installer, it's worth noting that the lay-out and structure of the new 7.6 installation program is significantly altered from that of previous hsc versions.
To begin with, Due to an important update registry patch which must be correctly installed, you may be required to reboot your system both before, and after, the process of the hsc7.6 installation. It was for This reason it was not possible to offer the alternative zip file method for hotSpotClicker installation, as was the case for previous versions.

Second, the hscinstaller will now properly recognize versions of jaws above 7.0, if found on your computer, and allow subsequent installation to these versions. If multiple versions of jaws are located on your computer, the second screen of the installation program will present them in a standard list box. If only one jaws version is found on your computer, this step will be automatically omitted.
note: It is only possible to install hotspot clicker into one version of jaws at a time, in any given installation session. However, you may of course reRun the installer at a later time, to install the clicker into as many supported jaws versions as you wish.

Third, The installer will now create a HotSpotClicker folder in the Program Files folder, which will contain all hotSpotClicker documentation, plus a couple of other important non script related hotspot clicker files. It will also deposit several hsc script files in the user-specific settings area of your installation of JAWS, usually in english installations, ...\settings\enu. But before doing this, the installer will now capture a backup copy of this ENU folder before hsc installation, to preserve your initial settings, in the event that you should wish to completely restore this folder to it's pre hsc installation state.

Forth, if an earlier version of hotspot clicker is detected in the particular version of jaws into which hsc is being installed, you will be asked whether you would like to create a backup folder containing the scripts for this previous hsc version.

At the successful conclusion of the installation, you will be asked to reboot the system, to complete the installation process.
note that it is important that this be carried out before inadvertently giving focus to any application which may already have hsc connection code installed.

Connecting The Hot Spot Clicker To Your application.

The first thing to establish before seeking to connect the hotSpotClicker to an application, is whether that application already has any factory, or custom, jaws Scripts written for it, or not.
(please See below for step by step instructions on how to determine this.)
If it doesn't, the full hsc connection process is remarkably straight forward, and will be covered first. If it does, then the full connection process may vary in complexity, depending on two main factors::
A.) the particular way the script author has chosen to construct a couple of key functions in the jaws script file; and,
B.) whether you require the full hsc feature set for that application, Namely, the Automatic set switching, and Spot Prompter features, or not.
For more information on these two features, please see: Automatic hsc set switching feature. and, Hsc Window prompt creator, "spot prompter."

Note that you will need to perform the steps in this section once for each application with which you wish to use the Hotspot Clicker.
*** Important Note! the described method below should only be applied, for applications for which you have not purchased any custom scripts, where the author has deliberately withheld the jaws script source, (jss,) file. Such as Dancing Dots CakeTalking, or TAndT consultencies Itunes scripts, etc. You can not use HotSpotClicker to supplement scripts such as these, unless the author has already included the necessary code in their scripts. Following the below procedure in these situations, will almost certainly break functionality of such scripts, most likely requiring a script reinstall to repair. If you are Unsure about this, before follwoing the below procedure, focus in your desired application, and press JawsKey+q. if you hear jaws report that your application name scripts are loaded, and then you follow the below procedure and discover at step 3, what appears to be a blank jss file, then it almost certainly means you should not proceed past step 3, and should close the script manager with alt+f4, without making any changes or recompiling that jss file.

To determine whether your application already has any jaws scripts associated with it, do the following:

1. focus within the application to which you would like to connect hsc.
2. Pres jawsKey+0 from the top numbers row, to open the jaws script manager. (note: you can alternatively press jawsKey+f2, s, then enter if you prefer.)
   If successful, you should hear jaws say something like, "jaws script manager, - [YourApplicationName].jss.
3. Carefully explore the file by pressing the down Arrow key a few times, taking care not to bump any letters or numbers on your keyboard.
   If you continually hear a windows error sound, and/Or, jaws saying, "blank," then excluding the special situation noted above, this means that jaws has no prior script file previously constructed for your application; In this case, follow the steps below to fully connect the hotspot clicker to this application.

(If however, you find the jss script file already contains some information, please click below to skip to: What if my jss file already contains prior information/code.

note: Insure to fully read the following steps before actually clicking the link to open the new window, in order to be aware of the tasks to be performed once the window is open.

1. Click the link at the end of this list to open a new browser window, containing the full HotSpotClicker connection code to be pasted into the blank jss file.
2. When this new window opens, press control+A, to select all the text therein.
3. Press Control+c to copy the selected text to the clipboard.
4. Close the window using alt+f4.>
5. Press Alt+tab until you arrive at the jaws script manager window, with your application's blank jss file.
6. Press Control+v, to paste the contents of the clipboard into the jss file. Your Cursor should now be at the bottom of the newly pasted information.
   
7. carefully explore the top and bottom of the file with your arrow keys, to insure the very last line in the file says,

   end function

   And that the very first line in the file, says,

   "Use "HotSpotClicker.jsb"

   (Tip: use control+Home to jump the cursor quickly to the top of the file for first line examination.)

8. Press Control+s to both save, and recompile the script file. If successful, you should hear a happy sound from windows, and jaws should say, "compile complete."
   if you do, then Congratulations! That's it! your done! Press Alt+f4 to close the script manager. You Are now ready to try defining your first hotSpot.

What If My JSS File Already Contains Prior Information/code.

Assuming you have opened your application's jss file in the jaws script manager, and you've found it contains some prior script code, do the following to add main HotSpotClicker functionality to the application.

1. Carefully select the line exactly as it appears below, and then press control+c, to copy it to the clipboard:

use "HotSpotClicker.jsb"

2. Press Alt+tab until you arrive at the jaws Script manager, with your application's jss file open.
3. Insure your cursor is at the very top of your jss file, and at the very beginning of the first line, by pressing control+home, then the home key.
4. Press Control+v, to paste this single line into the Jss file.
5. Now press control+s, to both save and recompile the script file with the new hotSpotClicker support.
   If successful, you should hear a happy sound from windows, and jaws should say, "compile complete."
   That's it! your done! And You Are ready to try defining your first hotSpot.

Adding support for auto set switching and spot prompter features to my non-blank jss file.

Do this if you want to install the complete set of HSC features.
If you are comfortable with the scripting language, you can discern the changes required simply by examining the full HotSpotClicker connection code But, for everybody else, the details are listed below.

Place focus in the application you are trying to adapt. In the following discussion, we will assume that you do not have a set of scripts from an author who does not provide the script source. In general, you can not connect HSC to such scripts, unless the author has chosen to install the necessary interfaces. And, attempting to recompile such scripts will most certainly require re-installation of the scripts. This is discussed more in Connecting HotSpotClicker To YourApplication In this section, we will assume that you are not connecting HSC to such proprietary scripts.

press insert+0 on the numbers row to open the script manager with a script file for that application. If none exists, one will be automatically created, and you can refer to the JSS Is Blank section For a quick way to create the necessary script file.

If, on the other hand, your file is not blank, then you should follow the directions in this section, to add the necessary lines to incorporate the clicker into your application. When all steps are complete, press control+s in the script manager to compile your scripts and place them in effect.

Near the top of the file, include the following statement, including the double quotes:
use "HotSpotClicker.jsb"
You can make that the top line of the script file if you like, or, if there are comment lines at the top of the file which start with a semicolon, you can move down past those comments, but prior to any script or function definitions. This allows your application file to link to the HotSpotClicker scripts for basic functionality.

To install automatic set switching, read and follow directions in the folowing section Can My Scripts Automatically Activate A HotSpot Set?

To install the window prompt feature, read and follow instructions in the section HSC window prompt creator Now, press control+s to compile your application scrip file, and then close the script manager.

This completes the connection between HSC and your application. When you place focus inyour application, a skeleton .HSC file will be created for that application, and a backup copy of the application JKM file will be created. Then, all the HSC master hotKeys will be added to the existing JKM file. then, you will be ready to start creating hot spots.

Once focused in your application, press control+alt+shift+h to view a list of all hotkeys assigned to the HotSpotClicker.

Dealing With JAWS Updates

1. Install the new version of jaws, but don't merge yet.
2. In your settings\enu folder of the old version of jaws, there is a Personalized Settings folder. Copy all the .HSC files from the Personalized Settings folder of the old jaws, into the Personalized settings folder of the new version. If you were using HotSpotClicker prior to version 7.6, you will have a bunch of .HSC files. Hotspots created with version 7.6 or later will be organized into folders by application. In that case, just copy those folders.
3. Now, you are free to perform the merge, or to copy across all the script files you want from the old version. Those go in the settings\enu folder.
4. When you focus in each HSC-connected application, the keymap should be updated. If it isn't, then go to the actions menu, and choose the item that says:
   Keymap, refresh.
   the key map for that application will be updated with your hotspot keys.

Migrating Hot Spots From Previous Versions.

Hotspot files from version 7.0 and 7.5 are already entirely compatible with this version. You won't need to do anything at all.

For versions prior to 7.0, Copy your old hot spot files into the personalizedSettings folder, and rename them to have an .HSC extension. When you focus in your application for the first time with the clicker connected, it will automatically detect that your files are the old format, and will convert them to the new format without any intervention on your part.

Including The clicker In Your Application's Keyboard Assignments.

When you focus in your application for the first time with the HotSpot clicker , the clicker will check your key map to see if the hot keys required for clicker operation are already installed. If not, it will install them automatically. Normally, this step requires no manual intervention on your part.

However, if any of those keys are already assigned to a different script, the virtual viewer will open, informing you of the conflict. press enter on the single link in that dialog to open your web browser, which will allow you to refer to a relevant location in the file you are presently reading for more information.

After the master hot keys have been installed for the first time, you may find that you have to place focus elsewhere, then return it to the application before the HotSpotClicker will start working. This is because some versions of JAWS, such as 6.0 and later, do not detect that the KeyMap file has been altered, and are operating out of memory. The elegant and proper solution for this problem has been attempted but, unfortunately, leads to other kinds of malfunctions which are even less desireable. So, switching focus away, then switching it back again is sometimes necessary to get JAWS properly initialized.

The KeyPressedEvent.

This is a special consideration when connecting HSC to Internet Explorer, but may apply to other applications as well. If you want to use HotSpotClicker with Internet Explorer, read this section for basic background, and also read and follow specific instructions in the next section.

For many applications, you don't have to be concerned with this section at all. however, If the clicker does not detect key presses when you are assigning a hot key during the hotspot creation process, the problem most likely relates to the KeyPressedEvent. This is a special function which is invoked by JAWS each time a key is pressed. This problem occurs when your application script has a KeyPressedEvent function, but that function does not also call KeyPressedEvent. What normally happens, is that there are several functions by the same name, and all of them should run. When a key is pressed, jaws calls the KeypressedEvent which resides in your script file. If no such function exists in your script file, then JAWS will look in the HotSpotClicker file, and call the KeyPressedEvent that resides there. But, if your script does have a KeyPressedEvent, then that function should also call a function by that same name. And, when it sees that second call, JAWS will invoke the version in the HotSpotClicker as well. In this way, both versions will run, which is what you want. But, if your script KeyPressedEvent, does not also call KeyPressedEvent, then the chain is broken, and the version in the HotSpotClicker does not run.

this is in fact, the precise situation that does occur when seeking to tie the hotspotClicker into the internet explorer5-6.jss script file.

Should you encounter this problem, in something other than Internet Explorer, revise your KeyPressedEvent as follows.

To find this function in your applicaition script file:
A.) focus in the application for which you are seeking to integrate hotspot clicker.
B.) press either JawsKey+TopRowNumber0, or jawsKey+f2, then s, then enter, to open the script manager with your application scripts loaded; C.) press control+f, and type the words "KeyPressedEvent" into the edit box, without quotation marks, and press enter.

If you find a KeyPressedEvent, Down arrow past any variable declarations, until you find the first line that does not start with any of the following:
var,
int,
string,
or a semicolon ";".
Just above that first executable line, make a blank line and paste in the following line, exactly as it appears below:

KeyPressedEvent (nKey, strKeyName, nIsBrailleKey, nIsScriptKey)

now, If after doing this, you get an error when saving/recompiling this file with control+s, it may be because the writer of your script has used different variable names in your KeyPressedEvent function than we show here. If that happens, then you need to make sure that the names mentioned in parentheses in the above pasted line, are the same as your script author used in the opening line of their KeypressedEvent.
You will need to Change the names in parenthisies within the above pasted line in that particular script, to match the ones used in the top line of the KeyPressedEvent function in the script file you are dealing with.

Connecting to Internet Explorer Scripts

The FS-supplied scripts for Internet explorer do not pass the KeyPressedEvent on to the default scripts in all cases. So, it is necessary to slightly modify the fs-supplied script code to tell HotSpotClicker about the key press.
Using the instructions in the previous section, open the InternetExplorer scripts, and find the KeyPressedEvent. Cursor down a few lines, until you find a block of code that looks like the following:

ProcessBXModifiedKey(strKeyName)
if UserBufferIsActive() then
KeyPressedEvent(nKey,strKeyName,nIsBrailleKey,nIsScriptKey) ; default
return
endIf

This block calls the default version of KeyPressedEvent, only if the userBuffer is active, and not otherwise. When that happens, HotSpotClicker will also receive the key stroke. But, when the user buffer is not active, which is most of the time, HSC will not receive the keystroke. For some reason, these scripts do not want the Kdefault version called under some circumstances. We can honor that by adding two extra lines to this block. This will allow HSC to be notified in cases where the user buffer is not active.

Insert two lines just above the endif as follows

else
HSCKeyPressed (nKey,strKeyName,nIsBrailleKey,nIsScriptKey) ; default
When you are done, that block of code should look like the following:

ProcessBXModifiedKey(strKeyName)
if UserBufferIsActive() then
KeyPressedEvent(nKey,strKeyName,nIsBrailleKey,nIsScriptKey) ; default
return
else
HSCKeyPressed (nKey,strKeyName,nIsBrailleKey,nIsScriptKey)

Installing Auto Set switching and the Spot Prompter feature.

Just to recap, remember, for basic hsc functionality in any application, you need to insert that
use "hotSpotClicker.jsb"
line into the application's script file, Save/Recompile that file with control+s, , and perhaps double check the keypressed event situation, for each application in which you want hsc to operate.

Please be aware however, that we have not yet installed the hsc spot prompter, nor the dynamic auto set switching facilities. If you are eager to just start defining hot spots as quickly as possible, without dealing with multiple hotspot sets, or spot prompts, then you can leave installation of those facilities to a later time.
However if you would like to take full advantage of all hsc has to offer, and would like to install these features now, then please see: Can My Scripts Automatically Activate A HotSpot Set? and, Hsc Window prompt creator, "spot prompter."

Key Conflicts.

There are two kinds of keyboard assignment conflicts that can occur.

• Master Key conflicts which occur the first time the clicker is run with your application.
• Hot spot Hot Key conflicts, which arise when you define a new hotspot.

Master Key Conflicts.

One opportunity for conflict, involves those keys which are installed by the clicker when you first run it with your application. This occurs when hot keys normally assigned to support the clicker operation are already assigned in your application's key map. you have two options:

1. Open the JAWS Keyboard manager for your application, find and change the hot key, mentioned in the error message you received from the clicker, to a different hot key.
2. tell the Hot Spot Clicker to use different key assignments. This is described in Changing Hot Key Assignments.

Hot spot Hot Key conflicts.

A second situation in which conflict can occur happens during normal operation when you are assigning hot spots, and you press a hot key that is already assigned to a script in your application's script file, or which has been assigned to a previously assigned hot spot which you are now redefining. In such cases, you can choose to overwrite the present assignment, or you can choose a different hot key for your hot spot by clicking the "no" button in the wizard. You will be prompted for a different hot key, or you can press cancel to terminate the process entirely.

How It Works.

Definitions.

In this document, we use the shortcut symbol $jaws to refer to the complex full path to the personalized settings\enu folder. This is the path to the folder you open when you go to the start menu, type j until you hear your version of jaws, press right arrow twice to go to "explore my settings", and press enter. This path includes your user name, and thus is specific to your account. An example definition for $jaws is:
C:\Documents and Settings\MyUserName\Application Data\Freedom Scientific\JAWS\6.20\settings\enu

When we say hot spot, we mean a location where you would like to have the mouse either perform some kind of mouse click, or simply be moved to that location, to speak text or analyze color, or to serve as a starting point for a text or graphics search. Specialized forms of hotspots can set focus on the window in which they reside, or can switch to a different set of hotspots.

when we say Spot Prompt, or sometimes we say Window Prompt, we mean a window or control which should be monitored for acquiring focus, and an action which should be performed when focus lands in that window.

When we say toolTip, we mean an area on the screen which, when the mouse is allowed to dwell inside that area, displays a text label describing what will happen if you click there.

When we say Hot Key, we mean a user assigned key stroke which, when pressed, will activate the Hot Spot to which the Hot Key is assigned.

When we say Window, we mean a small region which JAWS thinks of as an area on the screen. These "windows" may or may not be apparent to a visual user, since they may not have visible borders. Usually, a larger area, such as a top level window, or an application main window, will be apparent. But, actually, every point on the screen is contained inside some kind of "window. That window may be very tiny, and may be completely included inside some larger window, which is called it's parent window. Windows are contain inside larger windows. And, at some point, some parent window, or grand parent window will be large enough to be made visible. edit boxes are windows, and usually are visible. Some other windows are not visible, but are known to the program, primarily for grouping items together for internal purposes, such as managing the dragging of controls.

So, when we talk about "the window containing the cursor", we are talking about the smallest window which completely encloses the cursor position, a window which may or may not have borders and be visible as a window to sighted users. A TopLevelWindow is usually a larger window that contains the child, and which has a title bar, but is contained inside the application main window. The application main window is usually the entire application, containing all windows for that application.
the key point of all this, is simply to alert you that there are more windows on screen than sighted people are aware of, and that JAWS makes use of these windows to identify various portions of the program. The JAWS HomeRow utility, activated with jawsKey+Spacebar is a rudamentary way for interested parties to navigate and explore the windows hierarchy, should that become necesary.

Creating And Activating Hotspots

there are two ways of activating a hot spot. If a hot key has been assigned, you can simply press the hot key to activate it. Or you can bring up a list of all currently active hot spots, arrow through the list, or simply type the first letter or letters of the hotspot label you wish to directly jump to, and press enter on the item of your choice to activate it. Those hot spots which have hot keys assigned will also list the key assignment.

The processing which occurs upon hotspot activation can be summarized as follows:

1. The user activates the hotspot, either by pressing the associated hot key, or choosing the hotspot from a list and pressing enter.
2. HSC positions the jaws cursor at the target location. This can also include searching a small area around the hotspot for a graphic, one of a list of colors, or even searching a window for a graphic name or a string of onscreen text.
3. Optionally, a user-supplied function can be run to modify, or further qualify the cursor location.
4. HSC performs the mouse action, if any, including all the various forms of mouse click.
5. Finally, a user supplied function can be run, if desired, to take any required action in the form of post-click processing.

You can also create multiple sets of hot spots. A special hot key brings up a list of existing sets, allowing you to choose the set to be activated, or to create a new hotspot set. Only one set is active at any one time, but that set will be active, even if you close and reopen the application.

You can also configure hotspot clicker, so that certain hotspot sets will automatically become active when specific windos, or parts of your application, gain focus. This makes it very convenient both to assign new hotspots as you learn about them, and have them be saved to the correct set for that situation, and also to have available in the hotspot list, only those relevant to the window with focus.
you can also have hotspotClicker load a hotspot set as part of a user created custom function, that can be attached to any hotspot itself, for situations in which there is no topLevelWindow change to trigger a set to load automatically.

For more information about creating additional sets, see Creating Additional Sets Of Hot Spots.

**There

Deleting A Hot Spot.

Firstly, it is important to make sure the proper HotSpot set is selected. if you have multiple sets of hotSpots defined, double click the control+alt+shift+f1 key, then use the arrow keys to make sure the set containing the hot spot you want to delete is selected as the active set. then, press enter to close that dialog.

With the proper HotSpot set selected, tripple click the Control+alt+Shift+f1 key. This will bring up a list of Hotspots in the current set. This dialog looks very much like the HotSpot help dialog. The top line of this buffer indicates whether you are actually viewing a list of hotspots, or a list of window prompts. press enter on this line to toggle to the opposite view. The rest of the language in this section refers to hotspots. but, the principals are the same, even if you are actually deleting window prompts.

Once you have selected the view you want, use the arrow keys to select the HotSpot you wish to delete, and press enter.

You will then be presented with a confirmation dialog, which allows you to confirm that you actually do wish to delete that hotSpot. The default answer is "no". so, shift+tab, or leftArrow, to the yes button, and press enter. the Selected Hotspot will be deleted from the currently active set, and the hot key, if is not attached to a hotspot in another set, will be removed from your application's key map.

remember, it is not really necessary to delete a hot spot before redefining it.You can just define it again, and the new definition will replace the old one, which will be saved by it's label. Or, if a spot by that name already exists, HSC will prompt you for a label by which the old spot should be saved.

Master Hot Keys

Unless otherwise noted, all HSC hot keys use the control+alt+shift modifiers together, in an effort to avoid most commonly used key assignments. a file is provided to allow you to change these assignments if necessary. This is discussed more in Key Conflicts

One of the primary hotkeys, (Control+alt+shift+A,), is assigned to initiate one of the two alternate versions of the hot spot assignment process.
The second primary operation hotkey, is assigned to the expanded hotspot assignment wizard, for identifying text string, color, or graphic searche criteria, control+alt+shift+g.
The third primary operation hotkey, (Control+alt+Shift+f1), is a multi purpose hotkey, selectable via single, double or tripple clicking the key. A single press of the key brings up the list of currently assigned hot spots in the currently active set.
Double clicking the key allows selection of the active set from the list of available sets, and provides the option to create a new set.
Tripple clicking that same key lets you select a hot spot to be deleted from the currently active set. For a complete list of hot keys, see List Of Hot Keys. or press Control+Alt+Shift+h in an application into which the hsc has been installed, and use the arrow keys to browse the list.

HotSpot Sets

You can define hotSpot sets which are unique to a particular internet web page in internet explorer. When a web page loads, for which you have defined a hotSpot set, the set can load automatically. This is discussed in more detail in Loading A Set Based On A Web Page URL

In other situations, complex aplications can host a multitude of mini-applications, often referred to as "pluggins". Again, the use of multiple Hot spot sets facilitates management of hot spots, localized to the context in which they are relevant, and helps make more efficient use of hot keys, since the same physical hot key can be used in multiple hot spot sets. But, it can be assigned to different meaningful names, and click different screen locations in each hot spot set.

For example, in audio/midi editing programs such as sound forge or sonar, which can hoast a number of soft synth and effects pluggins, it may be desirable to create a separate hotspot set for each of these pluggins. This may both facilitate faster and more efficient navigation to each hotspot within the list of available hotspots limited to that pluggin, and could enable the assignment of identical hotkeys to similar functions or parameters, in a variety of pluggin applications.

For example, you may find you have more than one type of compressor, reverb or soft synthesizer pluggin that you'd like to use, which all have similar parameters. Such as reverb time, compressor attack, effect mix, filter envelope etc, to which you'd like to assign identical hotkeys in each separate pluggin.

You might assign control+Shift+r to double click in a Reverb time edit box in one reverb pluggin, but the screen location which must be clicked in order to edit that parameter in another reverb pluggin, is almost certainly going to be quite different; In addition, this second alternate reverb pluggin may only provide graphical knobs, with no edit boxes at all, to interface with parameter values.
No problem! You can define one hotspot set for each pluggin, and have a unique hotspot in each set, which can perform different mouse actions suitable to operating that control in it's environment, that is dedicated to Reverb time. But, you can attach control+Shift+r to each of those hotspots. so, no matter which pluggin is active at the time, control+shift+r is always the magic key which you would use to edit Reverb time, using whatever method the individual pluggin requires.

Techniques like this would make it easier to both remember the shortcut key to activate that hotspot, or to locate identical hotspot labels for those parameters within the hotspot list for each pluggin, within each hotspot set.

Creating additional Sets Of Hotspots.

You can define additional sets of hot spots, at any time, by following the steps in this section. If you only want one set for now. you can skip to the next heading.

Change your application to focus in a different TopLevelWindow, for which you would like to create a hot spot set. Then Double click the Control+Alt+shift+f1 key to see the list of sets currently available. Initially, only one set will exist, which will be named after the application main window. Arrow down to the item that says
Create a New Hot Spot Set,
and press enter.

An edit box will open, showing the ToplevelWindow name which jaws suggests as the name for this new set. At a minimum, you should remove information from this string which will change as your application is operated. Leave only those characters which will always be present in the top level window name. If you prefer, you can totally arase the suggested name, and type in one of your own. However, if you plan to have JAWS switch hot spot sets automatically, as described in: Can My Scripts Automatically Activate A HotSpot Set?, then it is recommended that you use a name which is derived from the name suggested.

Once your name has been finalized, press enter. A new .HSC file will be created based on the name you entered,, and the new set will become the active set.

You will have been returned to your application, ready to begin defining hotspots in your newly created set, for that portion of your program. The set will initially be empty. However, any hot spots you define while this set is the active set, will be added to this set.

Tip: It is perfectly valid to have multiple sets, with different user friendly names, but referring to the same exact .HSC file. This might be appropriate if one common set will be used in multiple situations, but you would like to refer to them using different names. To do this, you must manually edit your main .HSC file, and add a line to the [hotspot file list] which looks like this:
YourFriendlyName=Filename.hsc
Where "YourFriendlyName" is a name you create, and the filename.hsc is the name of an existing hot spot set file in your Personalized Settings folder.

For information on how to allow your custom scripts to automatically cause the clicker to activate a different set of hot spots, see: Can My Scripts Automatically Activate A HotSpot Set?

Activating A HotSpot Set.

To manually choose which hotspot set is active, double click Control+alt+shift+f1. A dialog will open, listing the currently defined sets. The currently active set will be highlighted. Use your arrow keys to select the desired set and press enter. The new set will now be active.

Remember, you can also define a hotspot to switch to a new hotspot set, so you can load additional sets at the touch of a key. When defining the hot key, choose, "switch to a different hotspot set" as the positioning mode.

to have the set loaded automatically, read the section entitled Can My Scripts Automatically Activate A HotSpot Set?

Loading A Set Based On A Web Page URL

This feature lets you define a hotSpot set, named according to the URL of the page currently loaded. If automatic URL switching is enabled, as controlled by the URL switching option in the double click of HSC mods f1 dialog, then the hotSpot set will automatically load when the web page loads. Just as with window title switching, if you manually choose a set from that dialog, then the automatic URL switching option is disabled.

Window title automatic switching is discussed in Can My Scripts Automatically Activate A HotSpot Set?

HSC is specifically defined to cooperate with Internet Explorer, but could be extended to other browsers with small modifications to the code. The main HSC file will be the Internet Explorer.hsc file, and each web page you visit could be a hotspot set.

The rules governing which set will be loaded automatically are as follows:

1. if there is a set for the current page, use that set.
2. If not, if there is a set for the main page for this site, then use that set.
3. If not, then use the Internet Explorer main set.

For example, supposed you defined two sets, google.com and google.com/x. if the page currently open in your browser is google.com/x, then google.com/x.hsc will be loaded.
If you back out to google.com, then google.com.hsc will be loaded.
If you navigate to google.com/y, there is no set for that, but there is a set for the base page google.com, so google.com.hsc will be loaded.
If you now move to FreedomScientific.com, there is no set of any kind for that, not even the base page, so Internet Explorer.hsc will be loaded.

A filtering option has been added to the double click of hsc mods+f1, which allows you to only see set names which are associated with the current site. To toggle that filtering on or off, go to the jaws verbosity menu, and choose URL filtering. Press space bar to turn it on or off. When, off, all html related sets are displayed when Internet Explorer is the current application
If this option is enabled, then, from our examples above, the google sets would only appear in the list, if google.com, or one of the google subpages is loaded.

Organizing Spots Into Sets

Very often, in the interests of just getting up and running, you may start creating hotspots and window prompts for your application before you really have a good understanding of how your application is organized. All of your early hotspots and prompts will be contained in the main, default set. But, as you become more familiar with the application, you may realize that organizing hotspots and window prompts into sets provides a lot of convenience and clarity, and can dramatically increase the efficiency of your usage of hotkey real estate.

First, you must create the sets into which things will be shuffled. Double click HSC mods+f1, and choose "Create A new Set". As a default name of the new set, HSC will offer the name of the topLevel window that has focus at the time you create the set. If you wish to have HSC activate the new set automatically, you should use the offered name, taking care to remove dynamic information from the name. However, if you are willing to switch manually, you can specify any name you like, assuming it doesn't conflict with any existing set, or any automatic set you will want to create in the future. If you need to change a set name, you can do it manually by renaming the corresponding .hsc file, and by changing the corresponding entry in the [hotspot file list] section of the main .hsc file.

Once you have created your new sets, you can now move or copy hotspots or window prompts from the main set into any of your secondary sets.
Press hsc mods+f5 to bring up the organizer, and choose an organizing activity. Once you choose the activity, and then specify a target set, HSC will present a list of items of the chosen type, from the currently active set, on which you can perform the selected action. Press enter to perform the action. The list will remain open, so you can perform the same action on other items in the currently active set.
You will notice that, if you move an item, it will no longer appear in the list, since it no longer resides in the source set. Press escape when you have finished with those items.
If you want to perform a different action, or specify a different target set, you must press escape to close the organizer, then start it up again with hsc mods+f5.

Deleting a HotSpot Set.

To delete an entire secondary hotspot set, double click control+alt+shift+f1, and choose Delete A Hotspot Set from the menu. Then, select the set you wish to delete and press enter. If you answer yes to the cconfirmation, all hotspots in that set will be deleted, and the set will be removed. Also, all hotkeys which are unique to the deleted set will be removed from the jaws key map.

Importing A HotSpot Set

The set name will be inferred from TopLevelWindowName data inside the imported set. If you are importing an individual set, an edit box will open, allowing you to change that set name if you like. However, if automatic set switching is to be employed, you should accept the set name as suggested by HSC, since it will be expected to match the topLevelWindow name which will appear when the set should be activated.

Delete A HotSpot Set

Copy A HotSpot Set

Custom Documentation

If you create a set of hotspots you want to share with others, you might want to create a custom help file, to convey more detailed information to describe the use of your HotSpots. HSC allows you to create two levels of custom help for each hotspot set.
The first level is a custom hotKey summary. If you choose to create this level, then, your users can double click hsc mods+h, and read your custom summary. The first level help for the currently active set, if it is present, will be displayed in the virtual viewer, and can contain links which, when activated, will execute the hotspots you choose to mention in your summary.

In addition, you can creaate extended, detailed documentation of your hotspot set, which is referenced from the custom summary, and which will open in a separate window, based on the kind of file you choose to create. For example, if you create an .HTML file, your web browser will open, showing the second level help document, allowing your users to alt tab back and forth between that document, and the adapted application.

But, you must first create the custom summary in order to provide a link from HSC to your detailed file. In the next few paragraphs, we'll describe how to create the first level custom file, and how to encode the links, either to hotspots in the currently active set, or to the detailed document.

In the user-specific personalizedSettings folder, there is one folder for each application into which the .hsc files for that application are placed.
Note that HotSpotClicker prior to version 7.5 did not organize in this structure, but simply placed all .hsc files in the PersonalizedSettings folder. However, you can freely organize them into such folders manually, as long as the folder name is the same as the jaws configuration used for that application. HotSpotClicker will still find them.

To create the first level summary, inside the folder for your application, make a .txt file for each .hsc file you want to document. For example, if your set name is myApp.hsc, then create myApp.txt. the file is a free-format text file with two special considerations.

If you want to create a link to a hotspot in this set, you should enclose the hotspot name, or hotkey if one is attached, in less than and greater signs. All text on the line containing such a tag will be assumed to be the link text for activating that hotSpot. For example:
To speak the total, press <control+shift+1>
Note, don't rely on word wrap to do this. Press enter before starting a line which you intend to be a link, and enter again at the end of that line.

To create a link to your second level detailed document, specify the name of the file, including the extension, in a tag that looks like the following:
Read the detailed help document here <help=My detailed Help Document.html>

The example above is only illustrative. The words outside the enclosed tag on this line will form the text of the link associated with this file.
Note that the only spaces in this tag, are those which are actually part of the file name. But don't put spaces around the equal sign, Note also, just as above, don't rely on word wrap to do this. Press enter before starting a line which you intend to be a link, and enter again at the end of that line.

The detailed document is assumed to be placed in the same folder as the rest of the .hsc files for this application. It is not possible to Specify an alternate path name in this tag. The application which will open to display the file will be whatever application is associated with the file extension on the client's computer.

To omit the first-level virtual viewer file, and have double click of hsc mods +h jump directly to the detailed document, you must still provide a setName.txt file. But, the file should contain a single line, which defines the link to the detailed help file. If, for example, your detailed document was an html file, The single line should look like this:
<help=MyDetailedHelpFile.html>
If the first-level .txt file contains that single line, the virtual viewer will not open. Instead, the application associated with the extension you provide will open with the detailed document.

Positioning Methods.

Initially, The most obvious way to implement a clicker feature like this, might seem to be to simply have JAWS click at a pixel address relative to the edges of the screen. However such an unqualified technique has it's drawbacks, and is clearly an approach of last resort. The problem is that in such a case, JAWS will be blindly clicking at a predetermined screen location. If your screen is resized, or the application is dragged around, or in some special mode, clicking on a fixed screen location can have unexpected and unintended consequences. To help deal with this, you can specify one of five possible modes for establishing your screen location which can help adjust your locations for changes in screen format.

Positioning methods relate to how HSC determines the screen coordinates for the hotspot in question. In general, your screen is composed of individual dots of light, called pixels, which are arranged in a standard, square grid pattern. A particular location on the screen can be identified by specifying the number of pixels in from the left side, and a number of pixels down from the top of the screen. but, as you will see, HSC has some more sophisticated ways of determining screen locations.

If you feel unsure about which positioning method to use, don't be surprised. It is not always a clear cut decision. and, sometimes experimentation is the only way to know for sure. But, in most situations, you can not simply edit the definition, and change the positioning mode, because other information in the definition would need to change as well. To use a different positioning method, it is best to delete the hotspot, and redefine it from scratch with a different positioning mode.

For most situations, Application or Toplevelwindow relative positioning is a pretty good guess. but, in case it helps clarify, following is additional discussion of these methods.

Absolute Positioning

this method records the pixel addresses relative to the top and left edges of the screen. With this mode, you can even click locations outside your application, which can be useful, so long as the same exact set of applications is opened, with all of them in the same state, as when you defined the Hotspot. the disadvantage is that, if any of your applications are dragged around, the absolute location will not map to the same spot in your aplication window. If screen absolute positioning is used, then no validation is performed at all. The mouse click is simply performed at that absolute pixel address, without regard to any window criteria, or what application resides at that location at the time. this is really the most brute force method. Some applications are so horrible, that the JAWS functions which acquire things like control ID's or window names, simply return the same values for every window in the applicaition. so, no distinction can be made between various windows. This method essentially frees you from any restrictions, and just lets you click anywhere you want, regardless of how the screen changes.

Application Positioning

If Application relative, or TopLevelwindow positioning is used to define the HotSpot, then the hot spot will normally work only when the hotspot location lies inside the same window that was present at definition time. In other words, at the time the hot spot is defined, these scrips capture the class, name, control ID, TypeCode, and SubtypeCode of the window containing the mouse. When you activate the hot spot, jaws will expect that point to lie in a window matching all those criteria, and will not perform the mouse click if the criteria are not satisfied. To disable that check, and allow clicking outside the reference window, set the RestrictToWindow parameter in the definition to 0. The diference between these, is which window will serve as the reference point for determining the hot spot location. HSC records the absolute row and column, but those are not used in these modes. Only the WindowColumn and Windowrow values are used, and represent the distances from the top and left borders of the chosen window.

Parameters WindowRowbottom and WindowcolumnRight are filled in as well, and represent the distances between the hotSpot location, and the bottom and right sides of the windows respectively. These are used when you want to use a different corner of the window as a reference.

In Application Relative positioning - the cursor is positioned relative to the top and left edges of the application main window. The same location will be clicked, no matter what item has focus at the time the click is performed.
A disadvantage, is that, if the point of interest lies inside some child window, and that child window is moved around for some reason, then the actual point of interest will also move, and will no longer match the location of the originally defined hotspot. This would mean that activating that hotspot would cause the mouse to click at the wrong location, and will not produce the desired results.

TopLevelWindow Positioning

in TopLevelwindow positioning - the clicker starts with the window with focus, and drills upward in the windows hierarchy, looking for what JAWS considers a "topLevelwindow". . the cursor is positioned relative to the top and left edges of this topLevelwindow. Usually, this is some smaller window, contained inside the application main window, which has a title, and usually represents the area in which you are presently working. If this inner top level window gets moved around, your hot spot location will move along with it, making it more likely that the click location will still be in the correct place, to invoke the originally desired result.
The disadvantage with this positioning mode is that,if you are not focused on an item within the window which has the same toplevelWindowName as the one captured by your hotspot when you defined it, then you will receive an error announcement regarding unexpected topLevelWindowName, and you will need to operate the application to place focus within the window where the hotspot was initially defined.

To take a trivial example, suppose you are in NotePad, and have popped open the file open dialog. Initially, the edit box where you would type the filename has focus. the top level window is the file open dialog itself. That dialog is a smaller window which resides inside the notepad application main window. So, the main window contains the dialog, which contains the edit box. If you set a hotspot on the edit box, both methods would record the attributes of the edit box, and expect the spot location to reside inside a window with those same attributes. Application positioning would record the position as the distance from the top and left edges of the application main window. But, top level positioning would first check to see what control had focus, then find its top level window, which is the dialog, and record the position as the distance from the top and left edges of that dialog, and would also record the attributes of the dialog itself.
At activation time, Application positioning would find the application main window, jump so many pixels in from the top left corner, and expect to find an edit box. It could be a totally different dialog, but as long as it found an edit box at that location, the spot would be valid. On the other hand, topLevel positioning would determine what control had focus, find it's top level window, verify that that top level window had the correct attributes, and then jump in so many pixels from the top left corner of the top level window, and verify that an edit box resides at that locaition. In this case, if the dialog was not the correct dialog, the spot would have been considered invalid.

Current Window Positioning

If Current Window Relative positioning is used, then, the scripts do a system wide search for a window matching all the criteria specified in the .HSC file. The clicker first searches the application, then expands the search to the rest of the system. Only if such a window is found will a hot spot be activated. this mode can be useful if you wish to try and activate a hotspot in a window which may not currently have focus, but which may be partially visible onscreen. It is also especially good for pluggins, or little applets that are spawned off of the main application.

Focus Window Rlative Positioning

Choosing a Reference Corner.

For hotspots using Application, TopLevel, current or focus window positioning modes, you can choose which corner of the window will serve as the positioning reference. For all new hotspots, generated using HSC version 7.6 or later, a parameter called ReferenceCorner will be added to the definition. The parameter will be defaulted to TopLeft, consistent with earlier behavior, but can be changed to reference any of the other three corners of the reference window, using the definition editor, attached to hsc mods plus f4.

Older hotspots do not contain this parameter, and are defaulted to assume topLeft referencing. However, you can add this numeric parameter manually, using the definition editor. Also, due to errors in how the two alternative row and collumn numbers were generated in older versions of HSC, you must also modify WindowRowBottom and windowColumnright to be negative numbers. This is consistent with the principle that positive numbers move to the right, and down the screen, while negative numbers move left, and up screen from the reference corner

PCCursor Relative Positioning.

If PC Cursor relative positioning is used, your hot spot can be defined to be so many pixels away from that cursor. In this way, the hotspot can move around as the PC cursor moves. this is good for cases such as when you want to move the PC cursor up and down a list, or a table, and you want to be able to quickly read a different column of text in the same row, or a different line in the same column. but, your hot spot doesn't have to be horizontally or vertically paralell with the PC cursor. It can be up and to the right, down and to the left, or at any angle.

PC Cursor Row, means that the hot spot is assumed to be on the same row as the PC cursor. The position of the jaws cursor, relative to the PC cursor when the hotspot is defined, determines how far to the left or right the hotspot is located. An example of usage might be, if you were pressing down arrow to hear a table, one row at a time, speaking from left to right, but the information you want the hotspot to report is at the far right end of the line. You don't want to listen to all the front end stuff first. a PC Cursor row hotspot would move down along side your PC cursor, staying the prescribed distance to the left or right.

PC Cursor Column means that the hotspot is directly above or below the PC cursor. As the PC cursor moved left or right, the hotspot would move left or right accordingly to stay positioned directly above or below the PC cursor. For example, this might be used to check a collumn heading, as you move across a row in a table.

PC Cursor Both, means that your hotspot will move in both dimensions as the PC cursor moves. to help validate PC Cursor relative hotspots, HSC will expect the TopLevelWindow of the window with focus to be the same as when the hotspot was defined. If you do any text or graphics searches starting at the hotspot location, the toplevelWindow will be used as the window in which the search is performed.

Setting Focus.

Set Switching ShortCut.

Dynamic Window Names.

* Important: if various window names include dynamic information, such as document names or other information which may not remain constant for any number of reasons, and this information is not correctly removed, then the hotspot will fail when that dynamic information changes. you can edit the entry at definition time to leave only the information that is constant. You can also revise this information at a later time.
Incorrect assumptions about which windowname information is static and which is not, which is not always apparent, is among the most common reasons for why hotspots may begin to fail, after working perfectly immediately after their initial definition. For more information on customizing these comparison criteria, see: Customizing Comparison Criteria.

Creating A file To Store Hot Spot Definitions.

After you have connected the HotSpotClicker to your application, the first time you focus in that application, the clicker will automatically create a skeleton hsc file for your application in the PersonalizedSettings folder under JAWS.

This type of file has a standard format, and contains one or more sections. Each section contains one or more keys. Each key is followed by an equal sign, which is followed by the value of that key. Section names are enclosed in brackets. Note that the term "key" in this file does not correspond to a key from your keyboard, but is just a term used in defining this kind of format. Think of it as the key to finding that particular piece of data. In fact, the Key can be composed of any set of printable characters including spaces.

This file contains several sections.

the [main] section.

this section contains values which apply to all hotspots, and are used to preserve your preferences. This section will be automatically updated as you use the scripts.

In addition, there are a few items which you can modify manually with a text editor, which will affect global behavior, such as verbosity settings, and whether or not to speak debug information. But, most of them are also controlled through additions to the top of your verbosity menu, accessed with jawsKey+v.

the [hotspot file list] section.

this section lists the names of the various hotSpot sets. Immediately after installation, this section contains a single line, which means that only one hot spot set is initially defined. this line is of the following form:
TopLevelWindowName=TopLevelWindowname.hsc
The characters to the left of the equal sign are the name by which you will refer to the hotspot set. Usually, it is set to the topLevelWindow name present at the time you create the set, or the name by which jaws refers to your application. You can change these set names, but if the name no longer matches the ToplevelWindow name, then automatic set switching will not work. If you intend only to activate sets manually, then you can make those names anything that seems meaningful to you, except that there must be the original line:
MyApp=MyApp.hsc
Which is HotspotClicker's way of identifying the main hotspot set.

the characters to the right of the equal sign represent an actual file name where the hot spot information for the new set is stored. This does not need to be a full path name, ut just a simple file name, which will be located in your jaws PersonalizedSettings folder for your language. and, initially will refer to your MyApp.hsc file. In other words, this line of text can direct hot spot definitions to be placed in the very same file in which it resides, or in some secondary file, all based on set name. As new sets are defined, additional lines are added to this section, defining the secondary .HSC files which will contain each set.

The [slider units] section.

The HSC has the ability to scan predefined areas for visual sliders or track bars which can not be read in other ways. To learn more about how to deal with sliders, read the main section on: custom functions. and, in particular, see the section on function HSCProcessVerticalSlider.

This section contains the various strings used to described the units of measurement for sliders, such as percent, db, etc. the HSC already knows about several commonly used units. But, as you create sliders, you are asked to select the units of measure from the list in this section, and are given the opportunity to create new units. When you do so, your new units names are stored in this section.

Entries here are of the form
UnitsName=comment.
The comment field can be any characters you like, or nothing at all.

The [User functions] Area.

This section contains the names of user-supplied functions which can be executed after the mouse is routed to the hotSpot location, and the configured mouse action is performed. The HSC knows about some of it's own functions which can be used in this manner. But,while those functions are presented in the dialog that lets you choose such things, they do not appear in this section. But, if you wish to write your own script functions, and have them turn up in the list in that dialog, the wizard lets you specify the name of your custom function, and will place it in this section for future use.

These lines are of the form:
Functionname=Comment.
Where FunctionName is the name of a function in your script file, and the comment is any arbitrary string of characters.
The function should be of type Void, and can optionally require parameters. However, to supply parameters, you must use the definition editor to specify the parameter values. You can only provide constant values.
For example, the JAWS Delay function is not offered as a standard HSC function. but, you could specify it as a "create_your_own" function. Once you do this, the function= parameter in your definition will look like this:
function=delay
You do not need the left and right parentheses if no parameters are being supplied. However, the Delay builtin function requires one parameter, which is the number of tenths of a second to delay. So, to delay 3 seconds, you would need to use the definition editor, and modify your function line to look like this:
function=Delay(30)
Note that you can only supply constant parameters, such as fixed numbers, or quoted strings, consistent with the parameter types required by your function. but, you can not mention jaws variable names.

For more information on user-supplied custom functions, see: Custom functions.

HotSpot Sections.

In the main .HSC file, there is one section for each hotSpot in the main set. These sections contain a number of parameters as set up by the Wizard when the hot spot is created. The name in brackets is set to the name of the hot key if one is defined, or is set to the label if not. The individual parameters which comprise the hotSpot definition are discussed in more detail in Where does That Information Get Recorded

How To Assign a Hot Spot.

first, a brief note For those users requiring multiple hotspot sets: Before assigning any HotSpots, it is important to assure that you are assigning them to the desired set. If you have created more than one hotspot set, within the one application, then double click the hotspot help key, which is defaulted to Control+Alt+Shift+f1, and use the arrow keys to choose from the currently defined sets. For those users installing hotspot clicker for the first time, If you haven't yet created any hotspot sets, then Initially, there will be only one set defined for your application, and the below cautionary instructions will not be applicable to you. However, if you do find you need multiple sets for the one aplication, it's worth remembering to check this before assigning your hotspots.
If you change your mind later, regarding which set should contain a particular hotspot, you can move, or copy, it to a different set later using the hsc mods+f5 key stroke to organize hotspots, or window prompts into sets.

Hot spot definitions will be stored in the file which is active at the time you create the hot spot. This could either be the main application's hsc file, (which we'll refer to as MyApp.HSC) file, or in one of the secondary set files. Once you have selected the name of the set to which you want to add Hot Spots, press enter. That set will now be the active set until you change it, even if you completely shut down your system. If you have automatic set switching installed, automatic set switching will be disabled, to allow your selection to remain in effect. . And, when you double click the Control+Alt+shift+f1 key to see the list of available sets, the currently active set will be the one with focus.

With the HotSpotClicker scripts linked into your application scripts as described above, Place focus in the application you are trying to adapt. Either move the JAWS cursor to the position you want to click, or have a sighted person move the mouse to that location.
Now at this initial stage ,if you do not need to worry about matching or searching for a particular graphic, color or text string, use the standard hotspot definition wizard by pressing Control+Alt+shift+A on the keyboard. JAWS will record the location of the mouse cursor, and several attributes of the window in which that spot resides. It will then present a dialog, asking which kind of positioning you want to use. use up and down arrow to select a positioning mode and press enter. Experimentation may be the only way to determine which positioning mode is most appropriate for your situation. But, Application Relative positioning would be a good first guess. By default, the choice you made in the previous hot spot will already be highlighted. You can also press escape at this point to cancel this key assignment.

The Set Focus positioning method performs no mouse click, but simply directs the application's attention to a specific control, without altering that control. this is particularly useful with sliders, where you may want to set focus on the slider without changing its value, but where clicking tends to change the value of the slider.

For more discussion on the differences between the various methods of positioning, review the section on Positioning Methods.

next, the clicker may present you with a series of various types of window titles, and ask you to remove dynamic information from those titles. As you edit these strings, remove information that will change as the application is operated at different times, or under different circumstances. Leave only that information that you are confident will remain constant. When you press enter, the reduced strings are stored as NickNames. The nickname should either be equal to the first few characters of the original string, or should be contained in the original string, so that a match can be recognized.
And, because of this, the clicker won't need to ask you to edit all these window names for every spot you define within your application. the clicker builds up a data base of nicknames as you proceed, and will thus only need to queery you when it encounters new window names for which it has no entries.
This means that defining spots will get faster and less input intensive within the one application as you proceed.

it is recommended that you leave in place only the minimum amount of information, that you are reasonably confident will always remain a part of the window name string, and which defines the purpose of that window. You will have the opportunity to edit all these attributes manually later, but to gain maximum hotspot clicking success, this is quite an important part of the process.
note: since window names for, "current," window types, can change so dynamically, you may often find it necessary to delete *all* the information in current window name strings. you can do this by hitting the delete key when the window name is highlighted, and this should delete the whole current window name at once.

For more information on removing dynamic information from window titles, see: Customizing Comparison Criteria.

next, you are presented with a dialog asking what kind of action you want to perform at this location. Use the up and down arrow keys to choose the kind of click you want to perform, and press enter. Or, press escape to cancel. You can do all forms of single or double, left or right mouse clicks, simply move the jaws cursor to a location without doing a click, or you can move to that location and say a Chunk of text. Jaws defines a "chunk" as text that was written to a location on screen in a single operation. Often, this latter mode can be used to quickly cause a piece of text to be conveniently spoken with the press of a hot key. Options for SayWord, SayToCursor, sayToEndOfLine, and SayColorField are also provided.

For more information on which cursor is active after hot spot activation, and where the cursor will be located, please see: Cursor Restoration.

Next, Jaws will ask for a label for your hot spot.
if your hotspot happens to be located on either a graphic, or a piece of text, (what is often refered to as a "text string,") then this will be offered as a default label for the hotspot. If you plan to attach a hot key, and don't wish to assign a label, , you could press delete while the default label is still highlighted, forcing the label to be blank. But, it is strongly recommended that you include a label to help keep track of the meaning of your various hot spots. However, if you omit a label, and do not attach a hot key, the operation will be canceled. You must provide either a label or a hot key. but, it is best to supply both.

If you provided a label, you will next be asked whether you would like that label to be spoken when the hot spot is activated. Use up and down arrows to make your selection, and press enter.

next, jaws will ask if you wish to attach a hot key. If you choose no, and press enter, then the operation is complete. However, if you choose yes, JAWS will prompt you to press the hot key you wish to assign, and will start playing a short beep once per second, during which time it will wait for your key stroke. You have about 30 seconds before jaws politely gives up and cancels the operation. If you decide you wish to cancel, just press escape. Otherwise, press your hot key. JAWS will speak the name of the hot key captured, record the information, and return to normal operation.

The HSC will check your existing key map to see if you have chosen a hot key which has already been assigned to a script, either in your application, or in the default scripts, or whether you have already assigned this key to an existing hot spot in the current set, and will ask you to confirm whether or not you wish to continue with this assignment. If you choose cancel, the entire hot spot definition process will be terminated. If you say no, jaws will begin beeping again, waiting for another key to be pressed. If you like, you can press escape to cancel the complete operation, or press an available hot key to continue. Remember, it is perfectly legitimate to assign the same key to different hotspots in different sets.

If you are running jaws 6.0, and perhaps other versions as well, you may find that the new hot key is not immediately functional. This is because certain versions of JAWS do not know that the key map has been modified. If this happens, you will have to alt tab away from your application, and release the alt key to focus elsewhere. Then, alt tab back into the application to force the key map to be read by jaws. The elegant solution to this problem has been tried, and has other less desireable consequences. So, until this problem is address by Freedom Scientific, we're stuck with it.

Ok! congratulations! you're done assigning your first hotspot! Your hot spot should now be ready for use. You can record as many hot spots as you like, but only one hotSpot can be associated with any one hot key in the same set. yes, multiple hot spots can reference the same exact llocation. And, your hot key can include any combination of modifiers except for the JAWSKey. Leave the JAWSKey for use by Freedom Scietific.

JAWS will differentiate between left and right modifiers, if this option is set in the default.jcf configuration file. The HotSpotClicker will capture keys according to the setting of this option, which can be accessed through the config manager, under Settings, in the keyboard dialog. However, if you change that setting, you must edit the .HSC files manually to make the necessary adjustments to key names.

Including String Search, Graphics And Colors In Your Hot Spot Positioning Criteria.

A more advanced hotspot wizard is attached to the Control+AltShift+g keystroke. It performs all the features of the standard hotspot assignment wizard, but also looks for a graphic in the vicinity, captures the word at the cursor, and acquires the color at the mouse. If you do not need to include the presence of a graphic, text string, or a particular color value in your hotspot positioning criteria, you will find it sufficient, and quicker to use the standard wizard attached to Control+Alt+Shift+A.
This control+alt+shift+G expanded wizard is slightly slower, but permits creation of hotspots which are only valid when a particular graphic, text string, or color, is found at, or near, the hot spot location.

If a graphic is found near the mouse location, the HSC will ask you whether you want to track that graphic. This can cause the HSC to do one of four forms of search for that graphic before performing the mouse click. This is discussed in more detail in: PrePositioning the Cursor. If no graphic is found, the HSC will capture the word at the hotspot location, and ask if you want to condition the hotspot on the presence of that text string. You can choose to ignore the string, require that it be in it's present position, search nearby for that string, or search the entire window, as identified in your positioning mode selection, either from top down, or bottom up. If you choose anything but to ignore the string, you will also be asked if you want to require a match on the foreground and/or background colors. you can allow multiple colors for either foreground or background as described in: Color Searches. But, only the present foreground and background colors are captured by the wizard.

If no graphic is found, or if you chose not to search for the graphic, and if you chose to ignore the text string, the HSC will capture the color value found at the precise ppixel of the mouse location, and ask you if this color should be required as a part of the hotspot validation. The HSC can be caused to search a small area around that location, looking for that color, before the mouse acction is applied. this is discussed more in: PrePositioning the Cursor. You can allow a list of multiple valid colors for this pixel location, as described in: Color Searches. But, only the color present at the location at definition time is captured by the wizard.

Where does That Information Get Recorded.

After discussing where the HSC data files are stored, this section links you to a complete HotSpot parameter reference. These parameters can be accessed with a text editor, or, perhaps more conveniently, through the definition editor attached to HSC mods+f4, and are used to fully define a HotSpot.

First, a clarification. When we say $jaws we mean the folder you open when you hit the start menu, programs, type j until you hear your version of jaws, then press right arrow twice to go to "explore My settings", and press enter. This is the area associated with your user name, not the all users area, and is typically a path that ends in settings\enu. That is the folder where scripts are stored. Hotspot data is stored in subfolders under this $jaws folder.

In versions prior to 7.6, all information, for all applications, was stored in the $jaws\PersonalizedSettings folder. However, starting in version 7.6, a subfolder is created in the PersonalizedSettings folder, based on the application name. All hotspot data for that application is stored in that subfolder. We did that, because secondary hotspot sets, named based on topLevelWindow names, could easily conflict across applications. Separating applications into subfolders eliminates this problem. However, for backward compatibility, HSC will first check the PersonalizedSettings folder, to see if a .hsc file exists for this application. If it does, HSC will revert to the older method. If not, it will use the new method. And, if a myApp.hsc file does not exist using the new method, one will be created.

From our example above, if you are running an application called MyApp.exe, your information is recorded in a file called MyApp.HSC in the $jaws\PersonalizedSettings\MyApp folder.

The entry called ActiveFile, located in the [main] section of MyApp.HSC, is used to determine the exact name of the file in which the hot spot will be stored, based on the set that is active at the time the recording occurs. In other words, the hot spot definition itself will ei