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 230

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 Bryan Garaventa, for letting us use the JFetch utility, to allow checking for updates online.

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.

Thanks to Steve Spamer for Context Lists, hidden spots, and several other useful additions. Steve is the author of a heck of a lot of HotSpot sets for a variety of audio production applications. Steve has scripted up some Jaws scripts for Melodyne and Steve is the developer of the:

solution. you can Send Steve an E-mail.

thanks to PradipChandra Sikdar for the HSC Menus. Great idea.

And finally, Thanks to:

Phil Muir.

for spot rings, and 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. Any volunteers?

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

Hot Keys

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 active cursor, 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 or virtual cursor relative positioning modes, - Your hot spot can follow your PC or virtual cursor, staying a fixed distance vertically or horizontally from that 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 230
Download the Hot Spot Clicker 230 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

If you then merge your old scripts over from jaws 12 to 13, any scripts which called upon HSC from the jaws 12 installation, will now call upon it in jaws 13. The first time HSC runs for an application, and does not find a basic hotSpot file for that application, HSC will create an original HotSpot Set for that application. This set will not inherit any hotSpots you had previously defined for jaws 12. So, you will need to copy those over manually, as shown below. And, if you already ran HSC at least once, since that new, blank hotSpot set will now exist, you be warned by windows, as to whether you really want to overwrite that file. The answer is that you do want to overwrite the new set with your original set from the old version of JAWS.
To make this least painfil, follow the steps below.

1. Install the new version of jaws, but don't merge yet.
2. Go to the windows start menu, find the old version of jaws, and choose, explore JAWS, then Explore My Settings. In your settings\enu folder of the old version of jaws, there is a Personalized Settings folder. In the Personalized Settings folder, HSC will create one subfolder for each application. Those subfolders each contain one or more .HSC files.
   You can recognize the folders by name, associating them mentally with applications for which you know you have HotSpots. Copy all of those folders into the equivalent Personalized Settings folder in the new version of jaws.
   If you were using HotSpotClicker prior to version 7.6, you will have a bunch of .HSC files in the Personalized Settings folder, rather than application folders. Hotspots created with version 7.6 or later will be organized into folders by application.
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. Now that the HotSpots have been copied, run the HotSpotClicker installer to install HSC into the new version of JAWS
5. 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.

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 or invisible cursor, depending on which was active when the HotSpot was defined, 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. The invisible cursor should be used if no mouse click is required, and the application responds to the mouse ghobering over a location by changing the visual appearance. Such changes can affect the success of color or graphics searches.
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.

When you create a new set, consider whether you might like taht set to be loaded automatically as you operate your application. HSC will suggest an appropriate set name based on the method that will be used to activate the new set. For the typical non-internet application, the technique to use would be window title based switching. However, if you are building a set for a web page, or a subpage of a web site, the technique to be used will be URL based switching. Before creating a new set, double click the hsc mods f1 key. Down at the bottom of that dialog, you can choose which technique to use. If HSC says that automatic window title switching is not installed, refer to the installation instructions for how to connect HSC to your application. Usually, this means that the function HSCFocusChanged is not being called from the applications FocusChangedEvent.
Once that is installed correctly, you can enable automatic window title switching.

If you only want to activate the set manually, neither autimatic option needs to be selected.

Once you have selected the method for automatic activation. 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.

If web page switching is being used, jaws will ask if you want to create a set for the specific page that is loaded, or to create a set for the entire domain. In this case, if you use automatic switching, HSC wil look for an exact match between the address of the page being loaded, and a set name. If it does not find an exact match, it will look for a set for the entire domain. If that is not found, it will load the generic internet explorer main set.

If Window title switching is being used, 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

More success can be achieved by using virtual cursor relative positioning, because the virtual cursor can force the screen to update to place the located virtual item on screen. Additional positioning to a fixed distance from the virtual cursor is supported.

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 Base Folder there is one subfolder 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 several 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.

If you get that hotSpot working, only to find later that it doesn't work any more, using the incorrect positioning method is one likely cause of such failures. Not faithfully removing dynamic information from window names is another likely cause.

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.

Application Plus Current Relative

AT activation time, HSC indexes from the top left corner of the application, using the first set of coordinates. It then picks up the handle of the window that contains that indexed point. It then uses the second pair of coordinates to index the window it finds there.

This technique is good for cases where the smaller window does not have a name, or can not otherwise be uniquely identified, and found through a search. It presumes that, even though the smaller window may shift around some, it will not shift so far that the original spot location will no longer be inside that window. The first set of coordinates is simply used to find that window in the application frame, rather than a search, or some other technique. The second set is used to adjust the spot location to track the movement of the smaller window.

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.

TopLevel Hierarchical

At activation time, HSC finds the window with focus, uses that window to find the TopLevel window that contains focus, then uses the instructions, in reverse order, to descend from the TopLevel Windo down to the window of interest. Finally, it indexes the mouse against the top left corner of that small inner window to find the actual spot location.

Spots of this form are discussed in more detail in Window Browser

Window Search Positioning

If Window search Relative positioning is used, then, HSC does a system wide search for a window matching all the criteria specified in the .HSC file. It 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

Current Mouse Position relative positioning

When defining a spot like this, position the mouse at a location that will be typical of the kind of location at which this spot will be used. From that, you can establish color, graphics, window class information, and other data that will help the spot do it's job. In practice, the spot will be used at this, and other similar locations, where identical factors are present.

Choosing a Reference Corner.

For hotspots using Application, Application Plus Current, TopLevel, Window Search 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

PC or Virtual Cursor Relative Positioning.

This mode records the distance from the JAWS cursor to the active cursor at the time you create the hotspot. There are three flavors of this mode, whether to track horizontally, vertically, or both. Depending on your choice, either, or Both horizontal and vertacal distances are recorded. In this way, the hot spot will track along with your active cursor. Window validation is very similar to TopLevelWindow mode, and that top level window serves as the context for any graphics, color, or text positioning adjustments you specify.

If 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 virtual, or 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 active 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. In this mode, you can modify the WindowRow parameter in the definition, to create a fixed vertical offset as well.

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. In this mode, you can modify the WindowColumn parameter in the definition, to create a fixed horizontal offset as well.

PC Cursor Both, means that your hotspot will move in both dimensions as the PC cursor moves. to help validate PC or virtual 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.

Activate a Spot Ring

Virtual Cursor Positioning

Dynamic Window Names.

At the time the hotspot is defined, the wizard will present all window names in an edit box, allowing you to edit that information if required.

* 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.

Where To Store hotSpots

If you take no action to do otherwise, HSC will default to the latter, just as in previous versions. The base folder will be the PersonalizedSettings subfolder, which is in the user-specific settings area of JAWS.

To create a shared folder, Use Windows Explorer to creat the folder. Create one subfolder for each application, and place any hotspot files you already have in those subfolders. Note that the application subfolders must be properlay named for the application in order for HSC to find them. Focus in the application and press insert+q. Jaws will spell out the application name, followed by e x e. (ignore the . e x e part). Or, you can copy existing subfolders from a previous HSC installation. those are in the "personalizedSettings" folder in the user-specific settings area.
To tell HSC about that, open the folder where scripts are stored, and edit file HotSpotClicker.ini. In the [general] section, is a parameter called BasePath. By default, this is set to a dollar sign "$", which causes HSC to use the PersonalizedSettings folder as it's base folder. delete the dollar sign, and insert the fully qualified path to your folder. For example:
BasePath=c:\MyHSCFolder
It is a good idea to actually create the folder, and populate it with any existing hotspot sets before you tell HSC about it. If you have no existing HotSpot sets, then just create a blank folder, and HSC will do the rest.

Once HSC knows the base folder, it will create subfolders for each application it learns about, and will look in those subfolders for hotSpot information.

Note that, if you have multiple versions of jaws, you need to install the HotSpotClicker scritps into each version separately. If you want to use a shared folder, you need to edit the HotSpotClicker.ini file for each JAWS version, revising the BasePath parameter to point at the shared folder. That makes it possible to have some JAWS versions use the shared folder, and others use the local folder. You can mix and match. But, that means that, when you install a new version of jaws, not just an update, You need to tell the new version about the shared folder, as described.

Creating A file To Store Hot Spot Definitions.

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. In later versions of jaws, the verbosity items are accessed through the actions menu, hsc mods plus f10.

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 Base Folder 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.

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. Instead of the various window positioning methods, you can choose from a host of special kinds of hotSpots, such as one to switch sets, To activate a particular spot ring, to set focus on a control, or to activate an MSAA Object. 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.

The MSAA Object activation is discussed in Object Navigation 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 six 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. By That is the folder where scripts are stored. Unless you have defined an alternative BaseFolder, 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 Base 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 either be stored in the MyApp.HSC file, or in one of the secondary files, depending on which file you have active at the moment.

Each hot spot creates a section named after that hot spot. If a hot key is attached, the key name is used as the section name. If not, then the label is used.
Section headers are enclosed in brackets at the very top of each hotspot definition.

If you need to revise a hotspot, you can edit the .hsc file manually if you like, using a text editor. but, you'll find it more convenient to use the definition editor attached to control+alt+shift+f4. discussed more in Editing HotSpot Definitions.

Click on the following link to see a complete list of values you will see as a part of the hotspot definition: HotSpot Parameter Reference

Customizing Comparison Criteria.

If you are using application, TopLevelWindow, current or Focus Window-Relative positioning, and your hotspot begins to fail, it may be because the criteria used to find the window specified in the hotspot definition is overly specific, or contains dynamic information, which was valid when the hotspot was defined, but which has become invalid due to changes in your application's environment. For example, sometimes class names, especially those very long class names which start with "afx:" will retain the first few characters over time, but will change the last few characters each time the application is invoked.
Far more typically, Application or TopLevel window names often contain the name of the document you are working on at the time. Later, you may be operating on a different document and, thus, the window name will be different. Web pages are particularly famous for changing their title information as you move around the page. In addition, quite often you may find that the name of the, current, window, surrounding a particular hotspot, may alter too often or dynamically, and perhaps too unpredictably, to form a useful criteria for validating the hotspot. For example, when seeking to make hotspots for some kinds of Tab controls, it is often the case that the current window name in which the tab control hotspot resides, may dynamically alter to be synonymous with the last tab control that had focus, or that was last clicked on. This will very quickly invalidate a hotspot, (i.e. cause a function failed message,) which relied on the current window name remaining static, when it was defined. Thus, In such cases, you may often find it most expedient to just delete the whole current window name offered, such that the clicker will not seek to use current window name criteria, as part of the validation process for that spot. This will increase chances that your hotspot will actually succeed more often, but may increase the possibility of clicking in unexpected, and possibly undesired circumstances.

Dynamic information, meaning that wich changes during the operation of your program, can be removed from the comparison in several ways.

The clicker gives you a chance to remove such dynamic information from window titles at the time the hotSpot is defined. It does this by creating a database of window titles in the current Hot Spot set, where it stores actual window titles, along with their nicknames. the nickname should be a subset of the original window title, such that the nickname is equal to the first few characters of the actual title, or is completely contained within the original title.

when you define future hot spots in that same set, the clicker will consult it's database of nicknames, to see if the current window titles are already known. if so, it will use the nickname as part of the validation criteria for that window.

To cause the clicker to forget about a nickname, you must remove that entry from the [nicknames] section of the active .HSC file.

If you are using Application or TopLevelWindow positioning modes, you can learn what attribute of the window which contains the hot spot location is not matching by turning on the debug flag through the standard jaws verbosity dialog. Then, when you try to activate the HotSpot, JAWS will speak the name of the attribute which fails the comparison. This flag is described more in: The Debug Parameter.

If you are using Application or toplevelWindow relative positioning, HSC still applies criteria related to the actual window that contained the hotspot when it was defined, to determine if the hot spot is valid. In addition, if you choose to also search from the hotspot, looking for a graphic, a text string, or a pixel color, the results of that search can remain inside the application, or topLevelWindow, but cross in to a different child window, violating your validation criteria. To eliminate consideration of the child window, and allow positioning and searching to find valid locations anywhere inside the window you have selected as your positioning method, you must eliminate those criteria which are specific to that child window, as described below. The parameters which relate only to the child window are as follows:

• WindowName - string,
• WindowClass - string,
• ControlID - integer,
• WindowTypeCode - integer,
• WindowSubtypeCode - integer.

To ignore all child window attributes, you can disable child window validation through the verbosity menu. Press JAWSKey+v, and find Hotspot window Validation mode. Press space bar to turn it on or off. This setting is saved in the MyApp.hsc file, is applied at the time of hotspot activation, and, if off, causes HSC to ignore all these child window attributes. Normally, you should resolve the individual differences, and run with this mode turned on for the most security.

Sometimes, as you learn more about a particular application, you may wish to refine the validation criteria by manually revising the window names. To do this, you must edit the hotspot definition, either with a text editor, or from the definition editor using the control+alt+shift+f4 key stroke.

You can gain quick access to a hotspot's parameters by invoking the Hotspot definition editor, described in more detail in: Editing HotSpot Definitions.

Read through the definition, and evaluate the following to see if they might be overly specific, or contain
Information you suspect maybe altering dynamically such that it might be causing the hotspot to fail to fire as desired:

• WindowName - string,
• RealWindowName - string,
• topLevelName - string,
• AppWindowName - string,
• WindowClass - string,
• ControlID - integer,
• WindowTypeCode<- integer,
• WindowSubtypeCode - integer,

There are two ways to ignore a qualification criterion.

1. place an asterisk in column 1 of the line containing that criterion in the definition. this allows the original value to remain in the file, so you can easily restore it later. The HSC will ignore that value, and use the special code which will cause that criterion to be ignored.
2. Change the value to the right of the equal sign as described below.>

To Ignore integer values, set them to a negative 1, -1.

to ignore any string criterion, do the following. This discussion refers to windowName merely as an example, but should be applied generally to all string values in the comparison criteria. It does not apply to integer values. You can ignore integer values, but you can not specify multiple acceptable values, nor a range of values.

The normal string comparison mode requires that the characters listed here must be the same as the first few characters of the actual value from the window itself. For example, if the WindowName listed here is "Dog", and the actual window name found was "dog - page 1", the comparison would be satisfied, because the letters "dog" exist at the front of the actual window name. But, the "page 1" is likely to be a dynamic string, changing as the application is operated. so, we can satisfy the comparison, no matter what page we are on, by specifying only the constant portion of the window name. However, the HotSpotClicker does not know which parts of the name are dynamic, and records the entire string, relying on your manual intervention to scale it back to only constant values.

If you want to specify a string which is located somewhere in the middle of the window name, you can force that sort of comparison by inserting a caret "^" as the first character in the string. This special character is a wild card that can match any number of characters, of unknown value. But, you only need to do this if you are editing the .HSC file manually, or through the Edit Hotspot Definition dialog, to revise an existing hot spot. The assignment wizard will automatically insert this special character for you, if appropriate, when you custimize names during the creation process.

For example, if the window name was presently
"my Dog - page 1",
but later on, it might be
"your dog - page 16"
or
"Billy's dog - page 43",
we would recognize that the words
"dog - page"
remain constant. WE can force a match by making our windowName criteria look like this:
Windowname=^dog - page

There are two other special characters that can be used to control string comparisons. To use these, the string in your .HSC file must contain only one character, as defined in the following list:

• Asterisk "*" - means that the HSC will ignore this comparison, making all string values acceptable. Use this when you don't care what the window name is.
• Dollar sign "$", this means that the string must be blank, such as specifying that the window in question must not have a name. Remember, some windows, especially many small child windows don't have names.

Some programs are constructed in such a way that even integer values are dynamic, such as control ID's. If customizing your strings still does not resolve the issue, you may need to use HomeRow mode in JAWS, to determine if any of the integer criteria are dynamic, and eliminate them from the comparison. The HotSpotClicker knows that some ControlID's are equal to window handles, and thus are very dynamic. It checks for these cases, and, if necessary, sets the controlID to -1, which will prevent the control ID from being used as a criterion.

Customize HotSpot Creation.

If you are having frequent problems, where one of the child window attributes is causing hotspots to become invalid, you can tell the definition wizard to ignore that criteria for all newly defined hotspots. Criteria which are disabled will still be stored in the definition in the .hsc file, but will be stored with an asterisk "*" as the first character in the file key. This allows all possible values for that attribute, but allows you to use the definition editor to remove the asterisk, thus re-enabling the criterion at a later time. Note that, in the long term, to prevent clicking in the wrong place at the wrong time, it is better to correct the attribute, so that it is properly defined, than to remove it altogether.

To customize the wizard's data collection, press Control+Alt+shift+f10, and choose
Customize Child Window comparison Criteria
from the actions menu. Cursor down through the various child window attributes, and press space bar on an item to toggle it's state. Yes, means that the attribute will be recorded and used. No, means it will be recorded, but not used.

This customization is stored in the main .hsc file, and will apply to all subsequently defined hotspots. It does not affect existing hotspots.

If you want your customizations to also be applied to all new applications, choose the item that says
Save As the default for all new applications.
The current preferences will be recorded in file HotSpotClicker.hsc, which is the template from which all new main hsc files are created when connecting the clicker to new applications.

Likewise, if you change those preferences, and want to revert to what you last saved as a global setting, then choose:
Load Default Settings
The settings you last saved to the global file will be loaded, If no settings have been saved, then all criteria will be defaulted to the "on" condition, which is considered normal HSC operation.

Cursor Restoration.

This section discusses which cursor will be active after a hot spot is activated. In part, this depends on the mouse action you selected when you created the hot spot.

If parameter RestoreCursor is present in your definition, and is set to 0, HSC will not restore the cursor. This is useful when you want your custom function to determine which cursor should be active, and you don't want HSC overriding that. All new hotspots will contain this parameter, which will be set to 1. If this parameter is not present, it is defaulted to 1, which means HSC will control which cursor is left active, as described in the rest of this section.

If you chose to move to a location, rather than to say a chunk of text, or perform some kind of mouse click, then, after the hot spot is activated, the jaws cursor will always be active, and it will be parked at the location associated with this hot spot, no matter which cursor was active prior to hot spot activation. This behavior can not be customized without modifying the script source code.

However, if you choose the Say Chunk, one of the click options, or NoAction, then after the hot spot is activated, the cursor which was active before the click, will always be active afterwords as well. The default behavior is that the JAWS cursor will remain at the click location. However, There are two ways you can customize this behavior. if you would like the JAWS cursor position to be restored to the location it occupied before the click was performed, and you want that to be the new default for all hotspots, you can go to the $jaws \Personalized Settings folder under JAWS,and manually edit the main .HSC file for your application. In the [main] section, you will find a line that looks like this:
RestoreCursorPosition=0 ; set to 1 to restore to previous locaition after the click.
As indicated by the comment on this line, changing the 0 to 1, then saving and closing the file will change this behavior, so that the JAWS cursor will be restored to it's previous location. This global customization will only apply to the current application. Each time you connect the clicker to a new application, when the main .HSC file is created, this behavior will default to remaining at the click location for that new application. but, your customization will remain in effect for the old application.

If you want to make this the default for all new applications, go to the $jaws folder and edit file HotSpotClicker.hsc. This is the main template which the HSC uses to create the main hsc file for new applications. Change that RestoreCursorPosition value in this file and save your changes. Now, all new applications to which you connect the clicker will exhibit this behavior as well.

If you want a given hotspot to behave differently than the global default, use the definition editor, attached to hsc mods plus f4. In each definition is a parameter by the same name, restoreCursorPosition which can override the default behavior. The values are as follows:
0 = Use the global default behavior
1 = Restore the cursor position to the location it occupied before hotspot activation
2 = Leave the cursor at the hotspot location

Custom Mouse Clicks.

This helps deal with the occasional situation where clicking the left or right button on the physical mouse, is different from clicking the jaws left mouse button. In such cases, using one of the custom click options should allow you to simulate clicking the actual mouse.

There are two parameters in the definition which control the behavior of the custom click. Use the definition editor to alter these if you need other than default behavior>

• CustomClickHover"Time - specified in tenths of a second, this controls how long the mouse must hover at the target location before the click is performed. Default is 0.
• CustomClickDuration - in tenths of a second. This is done by locking the mouse button, waiting the amount of time specified in this parameter, then unlocking the mouse button. Default is 1.

PrePositioning The Cursor.

If you find that the actual location you want to click seems to move around slightly, you can follow the steps in this section to cause the HSC to adjust the cursor position slightly before performing the mouse click.

If you are searching for a graphic, or a pixel color, the HSC will search a small area centered around the hotspot location, looking for the criterion you specify. the mouse action will be performed only if the search is successful. The HSC will search in a special form of expanding square, centered around the hotspot location. The search Limit values shown below will limit how large that square will become in each direction. A value of 5 defines a squaere which is 10 pixels across. But, you can manually edit the search limit parameters to allow for other area shapes and sizes. Edit the following parameters:
UpLimit
DownLimit
LeftLimit
RightLimit

Text and graphics searches, can also search the positioning window, either top down, or bottom up, looking for the nth occurrence of the string or the graphic.

you can have the HSC perform one, and only one, of the following actions prior to executing the mouse action:

1. Search for a graphic by it's graphic name,
2. Search for a text string, possibly including foreground and background colors.
3. Search for a single pixel color value,
4. Just move to the hotspot location and proceed.

Graphics searches.

Before creating hotspots involving graphics, you should first label those graphics with meaninful names using the JAWSKey+g labeler. Remember that graphics often change when clicked, and may even change depending on whether the mouse cursor is on the graphic or not. The autoGraphics labeler shipped with jaws does not take all these factors into account. You may need to label the graphic once with the jaws cursor positioned on it. then, label it again, with the same name, with the invisible cursor on the graphic, and the jaws cursor parked elsewhere. then, you may need to click the graphic with the jaws cursor, and see if it changes. If it does, then repeat the process giving the graphic a new name which reflects it's new state. the hotSpotClicker will deal with these graphics using the names you provide during this labeling process.

During the hotspot definition process, the advanced wizard tells you if a graphic is found near the hotspot location, and if mor ethan one graphic is found by the same name, tells you hwo many there are, and enumerates which of them is at the hotspot, such as 4 out of 10. Then, HSC asks you if you want to use that graphic as a positioning criterion. You can choose to ignore the graphic,
require the graphic at the spot location, search nearby, or to search the entire window, either from top down, or bottom up . You can search top down for the first occurrence, or for the nth occurrence, where N represents which of the multiple graphics with the same name is closest to the hotSpot. Or, you can search bottom up, either for the first from the bottom, or the nth occurrence. For example, you could search top down for the 4th out of 10, or bottom up for the 7th out of 10. Use caution as to which of these is most likely to remain constant. Note that, if you change your mind later, you can edit the definition to search from the other end, but need to adjust the graphic count accordingly. For example, change graphicCount=4 to 7.

If you choose not to ignore the graphic, then the hotspot location is taken to be the present position of the graphic, rather than the actual mouse location. TextOffset values in the definition can be used to further offset the click location from the located item, but these must be edited manually using the Definition Editor.

If you choose "search nearby", the hsc will search an expanding area centered around the hotspot location, up to the directional search limits, looking for a graphic of the name found at definition time. Searching nearby is intended for cases where the graphic tends to move only a few pixels. This method is rather slow, and is not well suited for large area searches.

If you choose to search the entire window, either top down or bottom up, the search is much faster. The window searched is controlled by the positioning mode you choose as defined in the following list:

• Absolute positioning - the topLevelWindow which contains the hotspot at the time it is activated will be searched. No validation is performed on that window.
• Application-relative positioning - the application main window will be searched.
• ToplevelWindow positioning - the ToplevelWindow of the window with focus will be searched.
• CurrentWindow Positioning - only the window containing the hotspot will be searched.

The GraphicCount parameter in the hotspot definition can be used for top down and bottom up searches, to look for multiple occurrences of a graphic in situations where graphics can not be uniquely named. But, if you change directions of the search, remember to also adjust the Graphic Count.

Tip: To enumerate multiple graphics, position the jaws cursor on the graphic, and use hsc mods +f8 to figure out which one you are on, and how many there are.

If the graphic is not found, then the hotspot will fail. If it is, then the location is further modified by including the TextHorizontalOffset and TextVerticalOffset values, and the click is performed at the new location.

If you have a graphic which changes names when clicked, then, you may want to search for both names. You can specify multiple graphic names by editing the hotspot definition, and adding the additional name to the Graphicname field. Multiple names should be separated by a vertical bar "|", without intervening spaces, such as "dog|cat|jam".

Note that graphics under JAWS are problematic phenomena. Graphics labeled on one machine do not always translate well to other machines, and do not always work reliably even on your own machine. Your results may vary. In fact, they probably will.

Enumerating Graphics.

To find out which occurrence your jaws cursor is located on, press control_alt_shift+f7. HSC will search the positioning window for all occurrences of a graphic by the same name as the one on which the jaws cursor is located, and will report which occurrence this is, out of how many graphics. Then, you can use the definition editor to set the GraphicsCount key to the occurrence number you want.

To control which window is searched, double click control+alt+shift+f7 to cycle between the application main window, the TopLevelWindow which contains the cursor, or the child window containing the cursor itself.

The enumeration is always done top down. To figure out which occurrence that is when searching bottom up, subtract the occurrence number, from the total number of occurrences, and add 1.

Text Searches.

The text acquired by the wizard for this purpose, will be the word at the Hotspot location. You can expand or modify that text by editing the hotspot definition after the spot is defined.

If the string is not found, the hotspot is considered to be invalid. If the string is found, the location of the first character in that string is taken to be the present photspot position. You can further modify this position by editing the definition, and placing nonzero pixel offset values in the TextHorizontalOffset and TextVerticalOffset parameters.

the search options, and associated behaviors are as follows:

• Ignore - no search is made for any string.
• Require this string at this location - the line of text, starting at the hotspot location, and proceeding to the right edge of the child window is obtained. The number of characters in the search string are compared with the corresponding character positions in the screen text. A perfect match is required for hot spot validation.
• Search Nearby - HSC searches the line of text containing the hot spot and, if necessary the prior line, and the next line, looking for the required string.
• Top Down - HSC searches the positioning window for the string, starting at the top, and will find the occurrence of that string denoted by the TextCount parameter in the definition.
• Bottom Up - HSC searches the positioning window for the string, starting at the bottom and moving up, and will find the occurrence of that string denoted by the TextCount parameter in the definition.

The term " positioning window" refers to the position mode for the hotspot, Application, TopLevel, or Current window.

Searches can optionally also include text foreground and background color criteria. The colors are specified as RGB strings in the spot definition. Multiple colors can be specified for each criterion, by separating RGB strings with a vertical bar "|". You can learn text foreground colors, in rgb format, by double clicking jawsKey+5 on the numbers row.

If a search was required, and is successful, HSC will move the mouse to the start of the string, and apply the fixed text offsets, before performing the mouse action.

Searching For Unspecified Text

If you want to search for text of a particular foreground and/or background color, or a set of multiple foreground and/or background colors, but the text is variable, and thus can not be known ahead of time, you can do this by using the definition editor to set the text parameter to the special code caret star, ^*. This special code tells hsc that a search should be made for any text which matches the specified foreground and background colors. If you choose the "search Nearby" method, the four directional search limit parameters will limit how far the search will look from the original hotspot location. The TextCound Parameter will control how many words to look for.

Enumerating Text Strings.

To learn whether a given text string is the first occurrence, or the fourth occurrence, or whatever, place your jaws cursor on the word of interest, and pres control+alt+shif+f8. HSC will grab the word at the cursor, and then search the window for all occurrences of that word. It will report how many occurrences were found, and which one your cursor is on.

To control which window is searched, double click control+alt+shift+f7 to cycle between the application main window, the TopLevelWindow which contains the cursor, or the child window containing the cursor itself.

To locate a phrase comprised of multiple words on the same line, place the cursor at one end of the phrase, and double click control+alt+shift+f8. HSC will say, marked. then, place the jaws cursor at the other end of the phrase, and double click control+alt+shift+f8 again. It doesn't matter which end you mark first. HSC will then enumerate that phrase, and the cursor will be left at the start of the phrase.

For example, If you had enumerated the word "monkey, and there were three occurrences of monkey in the selected window, and your cursor was on the middle one, HSC would say monkey is item 2 of 3, Then you could configure a hotspot to do a top down search for the word monkey, and use the definition editor to set the TextCount to 2 in order to find that occurrence of the word.

The enumeration is always done top down. To figure out which occurrence that is when searching bottom up, subtract the occurrence number, from the total number of occurrences, and add 1.

Color Searches.

You can search for text with a certain foreground and background color. but, very often, you will be searching for a pixel of a certain color, which is not part of any text. To learn more about how to manually explore for pixel colors, read the section on Color And GraphicsExploration.

The HSC searches for colors if your hotspot does any of the following actions.
Items marked with an asterisk allow specification of multiple colors. Unmarked items allow only a single color to be specified.

1. * Track a string of text with specific foreground or background color - multiple.
2. * Track a pixel of a certain color - multiple.
3. speak a text phrase, or run a custom function, when a particular color is found - single.
4. When decoding a slider - single.

To support this, the following fields exist in the hotspot definition in the active .HSC file. the keys always exist, even if they are not used, so you can always edit them with the Edit Definition Dialog accessed by the control+alt+shift+f4 keystroke.

Shown here are the keys with default values, indicating that the feature is not used. If the feature is used, then realistic RGB color values will appear in these entries.

• color=* ;This would be the pixel color RGB value required at, or near, the hotspot location.
• ForegroundColor=* - the foreground color of the text string to search for.
• BackgroundColor=* - the background color of the text string to search for.
• graphicName=* ; this would be the graphic name. Or, a vertical bar separated list of graphic names.
• searchLimit=0 ;this parameter is included for backward compatibility, and is 0 in all new hotspots
• UpLimit, DownLimit, LeftLimit and RightLimit - the number of pixels HSC is allowed to search in each direction when looking for graphics or pixel colors

The pixel color, and text background and foreground colors are 9 digit RGB string values. You can specify a list of acceptable colors by adding the additional RGB value to the string, separated by avertical bar. for example:
BackgroundColor=000000000|255255255
This unlikely specification indicates that the background color could either be black or white.

RGB values are 9 digit strings, where the first three digits indicate the amount of red, the second triplet indicates the amount of green, and the third triplet indicates the amount of blue. The maximum value for each triplet is 255.

To learn RGB values for text foreground and background colors, (not for individual pixel or graphics colors,) position the jaws cursor on a character of interest, and then Double click insert+5 on the numbers row.

Color And graphics Exploration

this set of hotkeys is used to explore with the jaws or invisible cursor, to look for patches of color which may not appear as text, and are thus invisible to jaws. This information is useful when you want to have a hotSpot search for a color, or when exploring the colors of a slider control.

to learn RGB or integer color values for single pixels, Activate either the JAWS or Invisible cursor, then use the standard jaws mouse movement commands, alt+shift+NumPad arrow keys to move the cursor. Be aware that some controls will change their color, depending on whether the mouse is hovering over that area or not. In such cases, you may need to specify that either of those two colors is valid, unless you can know whether the mouse will be already at the correct location or not.

To automatically speak the color upon mouse movement, use control+alt+shift+period to toggle automatic color announcement on. when this mode is enabled, HSC will look at the color at the new location each time the cursor is moved. If the color is different from the color at the previous location, a short beep is played. When you stop moving the cursor, HSC will automatically speak the color. In this way, you can rapidly cursor around, knowing that you will hear the beep when the color changes, but without having to wait for the color to be spoken.

To repeat the color at the present cursor location, use alt+shift+NumPad 5. Double click that key to copy the RGB value to the clipboard. this is useful when copying the color value into the color attribute of a hotspot in the Definition Editor.

To have HSC automatically speak the name of a graphic with each movement of the mouse, as you move through the graphic, toggle automatic announcement of graphic name, using control+alt+shift+slash. This is useful in exploring the shape and size of a graphic. Note that jaws often thinks there are dead spots inside a graphic, such that the cursor is actually on the graphic, but jaws doesn't know it.

To move jaws or invisible cursor to a known absolute pixel address, activate the desired cursor, then press control+alt+shift+f9, and type in the row and column numbers, separated by a space.

To move the JAWS or Invisible cursor to a certain number of pixels relative to the top left corner of a particular window, first use a double click of HSC mods+f7 to choose which window to use as the reference. This rotates between application main window, topLevelWindow, and current window. HSC will speak the new context, and will play a sound which is associated with that particular context. You will hear that same sound, as a reminder of the current context, when you double click alt+shift+NumPadDelete, which will report the number of pixels from the top left corner of the selected window.
Then, manually position the cursor inside the window of interest, and double click hsc mods+f9.
Note that TopLevelWindow, in this case, refers to the topLevelWindow of the child window which contains the cursor at the moment, as opposed to the TopLevelwindow which contains the window which presently has focus.

to learn the absolute coordinates of the active cursor, press alt+shift+NumPadDelete.
To learn the number of pixels down, and to the right of the top, left corner of the currently selected window, double click alt+shift+NumPadDelete. Use double click of hsc mods+f7 to select the window context

To set the number of pixels to move with each press of a mouse movement keystroke, use JAWSKey+spaceBar to enter home row mode, and then left/right arrow to choose the number of pixels. then, use JAWSKey+spaceBar to exit home row mode.

To set a bookmark at the current cursor location, press alt+shift+PageDown on the NumPad. This is an absolute pixel address, which will be remembered until you restart jaws. To return the active cursor to that location, press alt+shift+PageUp on the NumPad.

to activate the jaws cursor, and route it to the invisible cursor, press alt+shift+NumPadMinus.

to activate the invisible cursor, and route it to the jaws cursor location, press alt+shift+NumPadPlus.

To calculate the horizontal and vertical distances between two locations, Place jaws or invisible at the starting location and press alt+shift+home on the numPad. Move the cursor to the second location and press alt+shift+end. HSC will report the offset values, required to move from the starting point , to the cursor. Note that it is legal to define the start point with one cursor, and then move the other cursor to a new position before calculating the distances.

Recovery Spot.

For each Hotspot, you can define a separate HotSpot which will be executed if the original spot fails. To do this, you must use the definition editor, attached to HSC mods plus f4. Near the bottom of the definition, is an item called RecoverySpot. The characters to the right of the equal sign should be set to the name of the hotSpot which should be activated if this spot fails. Note that those characters are the characters between the brackets in the other spot, not it's label. If a hot key is attached to that spot, for example, this will be the hotkey name.

If you want the spot to fail quietly, neither taking any action, nor speaking any message, set the RecoverySpot to an asterisk "*". Setting RecoverySpot to a dollar sign "$" will cause an announcement to occur upon spot failure.

HotSpots generated with HSC versions prior to 7.6 will not have this parameter. So, it will need to be entered manually. Go to the right hand end of the last line in the definition, and press control+m to make a blank line. Then type the new item. An example would be:
RecoverySpot=control+shift+1

Object Navigation

1. an object browsing keyboard layer, which lets you use the NumPad arrow keys to navigate between MSAA objects, plus a host of number row keys to let you query various attributes of the current object.
2. The ability to define a hotspot which addresses the final object in your most recent browsing session. Such spots can either activate the object, or can just speak a set of aspects of the object, or can do both.

Object Browsing

While in the browsing layer, press f1, to hear a list of hot keys defined for the layer. Double click f1 to take an audio tour through the various sound effects and their meanings. Or, you can also access the list of object layer hot keys from the hsc mods + h, by pressing enter on the item near the bottom, that refers to Object navigation.

The browsing layer has two primary purposes:

• It can be used as yet another way to operate your computer, such as when you just have an urgent NVDA jones, and feel like poking around among objects.
• It is used to set up a navigation path for inclusion in the next HotSpot definition.

This browser maintains a review object, which is moved around, and equated to various objects in your system as you navigate.

In general, the numPad arrow keys are used to initialize the review object to the object with focus, and then to navigate from there by accessing peer level objects, moving to parent objects, or to the first child object. In addition, some objects contain elements, which can also be visited, using the 1 and 3 keys on the numPad, end and page down. Many buttons, and other actual controls, actually exist as elements of an object. It usually makes sense when opening the browsing layer, to press the home key to initialize your review object to the object with focus. This also routes the mouse cursor to the top left corner of that object.

Also, the numbers row contains hot keys which can be used to query the current object for the value of it's various attributes. Some of them provide additional information if double clicked. For example, the number 3, which reports the object value, when double clicked, will report the text that lies inside the physical boundaries of the object.
This set also includes a few toggle controls which represent your preferences about how the utility should operate, such as turning on or off the sound effects, filtering out apparently extraneous objects, and focus tracking.

Options are provided to allow the review object to be told to perform it's default_action, or to take the mouse to that object for experimental clicking, or to just repeat the summary of the present object.

Hierarchy Orientation

However, HSC treats this is a vertical tree. The main root is at the top, and you press down arrow to descend to lower and lower logical peer levels. Moving between peers at the same level is done using the left and right arrows. And, when you get to the end of a peer group, you hear a short buzz, but the level is not automatically changed. Instead, you review object remains unchanged. This makes it more obvious where you are in the tree, because your nesting level doesn't change automatically. Nodes do not have open and closed statuses. So, you don't enter the node unless you specifically choose to do so.

In addition, this orientation lends itself to using stereo sound effects to answer a common question about whether or not there are peers in either direction without having to operate the arrow keys and determine the answer experimentally. But rest assured, if you are a monaural participant, the sounds are all unique, so stereo is not essential.

Initializing the Review Object

Searching For Objects

Sound Effects

1. whether the object has peers, to the right, to the left, or both. Notice the small dink sounds, or finger snap.
2. Whether the object has children. Notice the drum sound.
3. Whether it contains elements. Notice the rattling sound.
4. Whetehr it is the object with application focus. Notice the old pohlaroid camera sound.

To take a tour through the various sound effects, and their meanings, while in the object layer, double click the question mark. Then, press enter on a description to hear the associated sound. This dialog also has controls to enable or disable the sounds. And, there is also a layer hot key on the numbers row to turn off sounds if you really find them annoying, or just can't see the benefit. However, not all sounds are disabled. Buzzes that limit navigation are always enabled, and the mouse monitor effects also do not honor this selection, since the monitoring would be mostly unusable without them.

To hear the current setting for soundsEnabled, press the associated numbers row key once. Or, double click to toggle.

Sound Files Listing

1. Children.wav - this node has children, but no peers, no elements, and is not the object in focus.
2. ChildrenElements.wav - an object with elements, that also has children
3. Elements.wav - an object with simple elements, but no children, peers, or focus
4. HSCBuzzer1, hscBuzzerLeft and HSCBuzzerRight.wav - no more objects in this direction.
5. HSCFocus.wav - This object has focus
6. HSCLayerOpen.wav and HSCLayerClose.wav - activation and deactivation of the object navigation keyboard layer
7. PeersBoth.wav - peers both left and right, no elements, no focus
8. PeersBothElements.wav - this object has elements, and peers in both directions.
9. PeersLeft.wav - to the left only
10. PeersLeftElements.wav
11. PeersRight.wav
12. PeersRightElements.wav
13. Mouse monitoring: HSCOTop.wav, HSCOBottom.wav, HSCOLeft.wav and HSCORight.wav.
14. Buzzers: HSCBuzzer1, HSCBuzzerLeft, HSCbuzzerright, and HSCBuzzerLow

Default Action

Node Filtering

Object Focus Tracking

Speak Object Location

Route Mouse To Object

Mousing around the object

Press the Mouse Monitor key, usually the page up key, to have HSC begin monitoring the position of the mouse relative to the edges of the current object. This key activates the jaws cursor, and exits the browsing layer, so you can mouse around.

There are two modes to this monitoring, which are controlled by a toggle assigned to the equals key in the layer. Press Equals once to hear the setting, or double click to change it. The two options are:

1. To have HSC notice when you leave the object, and force the mouse cursor back to the edge you just left. You'll hear a short buzz, and the mouse will return along the same path it traveled when it left the object.
2. Or, to allow exploration around the object, HSC will notice when you are outside, and periodically play a set of stereo sounds to indicate in which direction the cursor lies from the center of the object. This includes not just left, right, up or down, but also combinations of these, so you can tell if you are, for example, above and to the left of the object.

The sounds stop if you activate the PC cursor, or if the object becomes invisible. If you get lost, you can always activate the layer, and toggle the mouse restriction, with the equals key, to force the mouse to be routed back to the object. This will keep the monitoring active. Or, you can route mouse to object with insert+numPadMinus, which will route the mouse, but will terminate the monitoring.

Note that it is perfectly legitimate to explore the periphery of an object, and define a hotspot with use the corner of an object as it's reference point, but actually clicks a location that is outside the object. Simply allow the mouse to escape the object, and position it to the point of interest before defining the spot. The same parameter which controls which window corner serves as the reference for standard hotSpots applieds to object references as well.

Object HotSpots

• Focus the application in the place where you want the hotspot to be used.
• Activate the HSc object browsing layer with control+alt+shift+leftBracket.
• Press numPad home to initialize your review object to the object with focus. this will serve as the starting point for your navigation.
• Use the arrow keys to navigate to the object of interest. Don't worry about navigation mistakes. HSC doesn't care where you go until you actually decide to define the spot. The final location is all that matters.
• When you have found the object of interest, press the A key in the browsing layer to start the wizard, which will exit the browsing layer, and activate the wizard. Note that, in later versions of jaws, you can also follow your customary habbit of pressing hsc mods + A. However, in earlier versions of jaws, the first occurrence only exits the layer, and a second press is necessary.
• When asked about the positioning method, Choose Object Activation, and press enter
• The wizard will then confirm the target object by displaying some of the attributes of that object. If you don't hear it all, use the jaws cursor to examine the object. Finally, choose Yes to continue the definition, or no to cancel.
• Next, choose which object attributes are to be spoken. You can choose up to 4 attributes, in any order. If you feel like modifying that afterword, you can modify the spot definition, in a key called Output. Consult the Hotspot Parameter Reference document for the syntax.
• Finally, choose whether, and if so, how, the object should be activated. If you are just reading information, this might be none. Or, typically, such as if you want to toggle a checkbox, Do default action is a pretty good choice.
• To perform one of the standard mouse actions, choose, Other Mouse Action, Or Sspeak Screen Text. This leads to the standard list of mouse actions. choose the desired action from the second list and press enter
• Complete the remaining traditional wizard steps.

It is important to note that a single hotspot does not include do_default_action as part of it's path, but is strictly limited to simple moves. . That is, if the action you need to perform actually includes navigation to some object, doing default action on it, and then navigation to yet a different object, an operation like that can not be done in a single hotspot. It would be necessary to define two spots, and chain them together. The first would navigate to the first object, and then do default action. then, it would run the second spot, which would perform a completely different navigation. To actually set that up, you would need to manually perform the first leg of the navigation, and define the first spot to do default action. Then, you would execute that spot to set up the conditions for the second spot. Finally, perform the manual navigation required for the second leg, and then define the second spot. then, chain spot1 to spot 2.

Navigation Path Format

A Navigation path represents the series of moves required to navigate from the great ancestor, down to the target object of interest. Generally, this is a series of steps involving moving down to child objects, and moving across to peer objects.

However, since the number of objects at each peer level, and even the order in which they appear, could be dynamic, HSC prefers to use object names, rather than peer indices. So, if the object we need to go through on this peer level has a name, the path will be enhanced to record the object name, and HSC will search the peer level for the nth occurrence of the name. The number n, which identifies the occurrence number is calculated automatically, based on the conditions at the time you define the spot.

path syntax

For details about the format of a path element, consult the HSC parameter reference . Look for parameter "NavPath".

Targeted Elements

Activating an Object HotSpot

If you look at the hotSpot definition, lots of traditional information is missing. This is because no window matches are performed, Absolute screen cursor addressing is not used. color, graphics and text searches are not used, etc. Not all useless information has been eliminated. But, most has. However, the definition contains new information used to help qualify the object. such as the great ancestor's name, number of elements, the object name, and the object type. If these data gathered from the object that is actually found do not match the expected values, which were garnered from the object when you navigated to it manually, then the spot will fail. If debug is turned on, the first offending criterion is spoken.

the only one you can disable is the requirement that the target objectName be the same. . Some objects actually display dynamic information in the name field. If you need to disable that check, open the definition, and set the ObjectName parameter to an asterisk "*". Or, to specify that the located name must simply contain the the name in the definition, but need not be exactly equal to it, preceed the name with a caret "^". If the located object has no name at definition time, , HSC will require that the located object must have a blank name field by setting the name to a dollar sign "$".

The name comparison is case sensitive. Correct capitalization is required.

Viewing the Object As A Window

Window Browser

As described earlier, a window is represented by an enclosed area on your screen. Behind the scenes there are several pieces of information that HSC can learn about a window, not just where it is on screen, and usually the text contained within it, but identifying information such as name, class, control ID or type. HSC uses that information to discriminate between windows..

Similar to objects, windows are linked together in a tree-like structure. Each window contains 4 pieces of linkage information, which connect it to it's prior and next peer-level windows, to it's parent window, and perhaps it's first child window. There is only a link to the first child. If there are multiple children, you get to them by going first to the first child, then following along peer linkages to get to the child you want.

At the top of the tree is a single window that you can not access directly. But, you can see all it's children. Those typically represent applications that are running on your system. You can navigate between those high-level children, and descend into them to investigate their makeup.

This utility is designed to facilitate exploration of the windows hierarchy. And, it brings along with it yet one more way to define how a hotSpot identifies it's location.

To browse windows, press the window browsing layer activation key, Control+alt+shift+right bracket "]". You will hear the sound of a window opening, meaning that the layer is active, and than your keyboard has been fully redefined for purposes of the browser. This works exactly like the object browsing layer described earlier. Left and right arrows move between peer-level windows,up arrow goes to the parent window, and down arrow to the first child.

The number row keys are defined to give you direct access to various window attributes, and also includes a set of toggle controls for customizing how the browser works.

To review the total list of hotkeys, press f1 with the window browsing layer open. Pressing a key that does not below to the layer will close the layer. You can also find a topic on this in the main HSC hot key help, control+alt+shift+h.

Window Browsing around

As you move around from window to window, using the arrow keys, HSC will automatically speak various attributes of each window encountered. By default, this is set to name and class. However, you can customize what is spoken automatically by double clicking most of the numbers row keys to include, or exclude each of the items in the automatic list.

Once you have chosen the view you want, use your arrow keys to select the hotkey input, or the item of interest, and press enter. If you chose a hotspot or a prompt, An edit box will pop up containing all the keys and values associated with the current definition. You can use up and down arrows to examine the value of each key, use left and right arrows to examine the details of an entry, and delete or insert new characters in an existing line. However, this is not a full text editor, and thus provides somewhat limited functionality. you can change values, and even delete lines, or paste from the clipboard.

All lines in this buffer, except for the top line, are expected to be of the form:

key=value

Each Key must be unique, meaning that only one such key exists in the buffer. so, if you want to enter a remark to help document your hotspot, you could do it like this:
rem1=This hot spot is intended for personal use only.
rem2=We make no guarantees that it actually works.
Notice that the rem1 and rem2 keys are unique. This allows them to be preserved by the definition editor.

For detailed information about the parameters and their associated values, consult the HotSpot Parameter Reference

Two special hotkeys are provided to assist in editing numerical selection fields, such as mode and action, where each unique number has a special significance. Use control+alt+shift, in conjunction with f11 and f12, to move between the various valid options for that parameter.

if you press enter in this dialog, the HSC moves on to a confirmation step. So, To insert a line break, press control+m instead of the enter key

In the confirmation step, you are asked whether you want to save your revised definition, even if you did not make any changes. If you choose no, then the changes will be discarded. If you choose cancel, the editor will be re-activated showing the changes you have made so far, and You can continue editing your definition. If you choose yes, which is the default, the information will be saved, and new values will be applied. Keys that you removed will now be absent from the new definition.

To temporarily disable a criterion, place an asterisk "*" in the first character position of the line you want to disable.

If you wish to preserve all fields within the hsc editor, but still have hsc Ignore them, do not use a semicolon at the far left of the field line. If you do, it will not be saved, and will no longer show up in the hsc editor the next time that spot definition is opened. The way to do this, is to place an asterisk "*" in the left most column.

This paragraph relates only to hotspots, and not to window prompts. To change the hot key assigned to a hot spot, revise the top line of the buffer, which is enclosed in brackets, to reflect the key name, with the modifiers in the correct order, control, alt, shift, windows. When the definition is saved, the jkm file will be automatically updated. But, you might have to shake JAWS up a bit to get it to notice. Focus in another application, or on the desk top, then return to your application. This will work even if no hot key is presently attached. such hotspots have the label duplicated in the brackets. Just erase that duplicated label from between the brackets, and replace it with your keyName. Remember, specify modifiers in the order, Control, Alt, Shift, Windows. Do not use the JAWSKey.

for more information on how to revise a hot spot definition, see Customizing Comparison Criteria.

Adding A Hot Key To An Existing Hot Spot.

If you already defined a hot spot, but have not yet attached a hot key to it, you can do so by following the manual steps listed in this section.

Activate the Edit Hotspot Definition dialog with Control+alt+shift+f4, and select the hotspot to which you wish to add the hotKey. the top line of this buffer will contain the label text, enclosed in brackets. Change the characters enclosed in brackets to the name of the key you want to attach. You must include the modifiers, in a particular order, separated by plus signs, such as Control+Alt+Shift+f2. Note that the order of the modifiers is significant, and that capitalization matters. Always list them in this order, Control, Alt, Shift, Windows.

When finished, pres enter and confirm that you wish to save the new definition. Your application's JKM file will be updated automatically, and your new hot key should be in effect.

How Do I find Out what Hot Spots Are Defined.

While focused in your application, press control+alt+shift+f1, or the key you have assigned to the HSCHotSpotHelp. HSC will present a dialog listing all hot spots in the currently active set, listing the key assigned, and the label you entered when defining each hot spot. Use the up and down arrow to review the list of keys. Press escape to close the dialog. You can press enter on any of the hot spots listed to activate that spot and do the click action .

To switch to a different set of hot spots, double click the Control+Alt+Shift+f1 key, arrow to the desired set and press enter.

Fine Tuning A HotSpot Location.

This section addresses situations where your hotspot is no longer in the correct position, and you want to adjust the location. There are several distinct approaches described here.

Finding The Location Without Clicking

If you define a HotSpot that does some kind of mouse click, but you find that it doesn't cause the intended action, it may be because the mouse was not position at exactly the correct location. So, you would like to return the mouse back to that location so you can do some exploring, but you dont want to perform the mouse click, in case it has other unintended consequences.

So, with the correct HotSpot set active, press Control+Alt+Shift+f2.

This dialog looks exactly like the HotSpotHelp dialog. But, you can arrow to the item you want, and press enter. The jaws cursor will be activated, and will be moved to the location currently defined for that item, but no click will be performed. Now, you can fine tune the position by moving the mouse. then, you can redefine the HotSpot in the usual way, with the updated location, or simply adjust the position as described below.

Which Window corner to Use As A Reference.

If you believe that the correct reference window is being used, but the precise location is not quite correct, and needs to be adjusted, there are several approaches you can take.

First, consider whether the correct window edges are serving as the positioning reference. Usually, controls are placed a fixed distance from the top and left edges. However, if that is not the case, using one of the other edges as a reference may lead to more constant distances. Use the definition editor, attached to HSC mods + f4, to change the ReferenceCorner parameter to specify the edges that are more likely to remain a fixed distance from your hotspot. The Reference Corner is a numeric field, so you can use the Value Change keys, hsc mods + f11 and f12 to alter this parameter.

Here is a listing of the possible selections for this parameter, and which position parameters in the definition are used for that mode:
0 = TopLeft - WindowColumn and WindowRow
1 = TopRight - WindowColumnRight and WindowRow
2 = BottomLeft - WindowColumn and WindowRowBottom
3 = BottomRight - WindowColumnRight and WindowRowBottom

Updating Position To The Jaws Cursor.

If the referenceCorner is correct, but you still need to alter the position, you can update the definition as described in the next two paragraphs.

If a single hotspot is affected, you can place the jaws cursor at the new position, and update the hotspot position as described in this paragraph. Activate the JAWS cursor, and place it at the new location for the hotspot. Go to the HSC actions menu, hsc mods + f10, choose Adjust a Hotspot Location" and press enter. HSC will present a list of all hotspots in the currently active set, which use absolute, application, TopLevel, Current Window, or PC-relative positioning. use the arrow keys to select the hotspot to be adjusted, and press enter. The hotspot location will then be updated to the position of the jaws cursor.

Specifying temporary Offsets For Multiple HotSpots.

If many hotspots are at the wrong position, with each of them being misplaced by the same exact number of pixels, you may wish to specify a global offset, which will be applied to all selected hotspots. This is a way of moving a group of hotspots by a fixed amount. This should be used for temporary purposes, only to resolve a problem. It is best to incorporate the offsets into the affected spots, in case you need to use this feature again in the future on a different set of hotspots.

There is one set of global offsets in each hotspot set, including a horizontal and a vertical value. You can specify which of the hotspots in the current set will use these global offsets. If a hotspot is configured to use the global offsets, the global horizontal offset will be added to the horizontal position value for the spot. Likewise, the vertical global offset willb e added to the vertical position values for the spot.

To determine the offset values, Use HSC mods + f2 to move the jaws cursor to the location of a hotspot which needs to be relocated. Then, press alt+shift+PageUp on the NumPad. HSC will mark that location as a starting point. Then, move the jaws or invisible cursor to the new location, and press alt+shift+NumPad end. HSC will calculate the horizontal and vertical distances, and save those calculated results in case you want to use them later., as described below.

To specify the offset values, and to select which hotspots in the currently active set will use the offsets, Go to the actions menu, hsc mods+f10. There are three separate items there which apply. You can specify which hotspots will use the offset values, manually enter or review the offset values, or force the calculated offset values described above to be used.

To choose which of the hotspots in the currently active set will use the offsets, press
Offsets, Select Which Hotspots will Use Them
a list of all hotspots in the currently active set will be presented. At the right end of each line is a yes/no indicator, which indicates whether that hotspot will use the global offsets or not. Note that you can not choose to use the horizontal, but not the vertical offset, or visa versa. It is all or nothing.
press enter on an item to change it's state. Also, at the top of the virtual buffer, are four lines which take special actions, such as to force all hotspots to use the offsets, or to disable all of them. If you pres enter on the line that says Select By Hotkey, you can press the hotkey attached to a hotspot to change it's state.

If you want to perform a mass, global edit to adjust the position information for a group of hotspots, to reflect the current offset values, press enter on the line that reads
Permanently apply ccurrent offsets to selected Hotspots.
This will modify all hotspots which are currently set to "Yes" in the list, such that their position information will be modified by the amount specified in the global offset values. This is a way of editing the position of a set of hotspots at once. This updates the row and column information to take the offsets into account. AT the end of this operation, all hotspots will become unselected, and the offset values will have been incorporated.
press escape when you are finished.

To specify the offset amounts manually, or to review them, press
Offsets, Specify or review offset amounts.
you will be prompted to enter the horizontal and vertical offset values. Type in the values, or press enter to accept the current value for each. Positive numbers mean the hotspot new location is to the right, or down, from the old location. Negative numbers mean that the new location is above, or to the left of, the old location. Press escape to cancel the operation. HSC will attempt to return focus to the application. However, due to vagaries in the relationship between jaws and various applications, this may not always happen. But, the virtual buffer of hotspots, described below, will not be presented if you escape out of the offset solicitations.

To use the calculated results, described earlier in this section, from the actions menu, press enter on the line that reads:
Offsets, Use Calculated Values
This will preload the global offset parameters with the results calculated with the alt+shift+home key stroke described above. This is eaquivalent to typing in those numbers manually, but does not affect which hotspots are currently using the offsets.

Moving To A Screen Location Manually.

To move to a location relative to the top left corner of the window containing the cursor, double click control+alt+shift+f9, and type in the horizontal offset, followed by the vertical offset, separated by a space.

You can learn the current location of jaws or invisible by pressing alt+shift+delete. Double click alt+shift+delete to learn the position relative to the left and top edges of the window containing the cursor.

to choose which window is used as a reference, either for learning or moving to a location, double click control+alt+shift+f7 to cycle between current window, topLevelwindow, and application window.

Sounds are provided to indicate the window context being used.

This is discussed in more detail in Color And Graphics Exploration

Confirmations