[olipcs]

This is a guide for using HotKeyNet for multiboxing.
The following topics are covered:

• Basic Concept
• Defining an Hotkey / Broadcasting keys
• Starting WoWs / Renaming Windows
• Resizing / Positioning of WoW-windows
• PiP / window switching
• Mousebroadcasting
• Advanced Stuff (Templates, round robin, ftl, etc...)
• More examples & informations

This guide can also be found in the wiki . (in an older version)

If you want have a look, how a sample script for 5-on-1 generated from this guide could look like, see the attached file.
(of course you need to edit the WoW-pathes and Window positions as you like)

v1 - 22. 11. 08 : first version
v1.1 2. 12.08 : added the wiki link
v1.2 4.3.09: Section: PiP / windowswitching: changed the use of <SetWinSize> and <SetWinPos> to <SetWinRect> (this requires HKN build 161 and above)
v1.3 - 10.09.2009: Added an explanation of <Template> to the 'Advanced Stuff' section / Added a sample script.

[olipcs]

HotKeyNet (HKN) is a currently free program for sending HotKeys to different windows (on one ore more than one pc) developed by Freddy.
The download, sample scripts and command reference can be found on: www.hotkeynet.com .

All actions of HKN are defined in a simple textfile, called the hkn-file or script, which can be edited with a simple texteditor.

if you now say: "Yeah great i don't want to read the concepts and explanations, give me a simple script!"

-no problem: if you want to get the files first, here are sample scripts !

Ah, you stayed , so back to the concept:

The basic concept of HotKeyNet is that it is a program what simply waits on a key-trigger to run an action, like for example pressing 'ctrl+o' to run winamp. So in general HKN can be used for a lot of other things than multiboxing.

In the following I will describe the script-definitions and commands necessary to use hkn for multiboxing.

[olipcs]

General:

The command to define a Hotkey is: <Hotkey ..>

A simple example to broadcast '1' to a window named 'wow1' on the local computer would look like:

<hotkey 1>
 	<sendpc local>
      	<sendwin wow1>
      	<key 1>

So basicaly in the <hotkey ..>-command the trigger is defiend (line 1), here '1', and in the following (line 2-4) an action to execute.

As a trigger simple keys like '1','a','F11' can be used or combinations of modifiers and a key.
As a modifier the normal modifiers 'shift','ctrl','alt' can be used or with the <UseKeyAsModifier>-command any other key can be used.
For the hole definition of <HotKey> see: HKN: HotKey .
For how to figure out keynames see: HKN: Keynames .

Broadcasting Keys to WoW windows

For broadcasting a hole bunch of keys to different WoW windows the following example (here for 5 boxing on one pc) can be used:

//-----------------------------------------------------------
// DEFINE MAIL LABELS FOR SENDING KEY STROKES.
//-----------------------------------------------------------
<Label w1 Local SendWinM WoW1>
<Label w2 Local SendWinM WoW2>
<Label w3 Local SendWinM WoW3>
<Label w4 Local SendWinM WoW4>
<Label w5 Local SendWinM WoW5>

//-----------------------------------------------------------
// DEFINE HOTKEYS FOR ALL KEY COMBINATIONS THAT WILL GET
// SENT TO ALL WOWS. ADD MORE KEY COMBO'S IF YOU WANT.
//-----------------------------------------------------------
<KeyList MyList A-Z, 0-9, Enter, Tab, Oem4, Space, Comma, Oem6 except W, A, S, D, Q, E, L>

<Hotkey MyList; Shift MyList; Alt MyList; Ctrl MyList>
  	 <SendLabel w1, w2, w3, w4, w5>
   	<Key %Trigger%>

this does the following:

1. Defining five <Label..>-commands, one for each WoW-window.

A <Label ..> -command can be used to summerize for a setup to which window, running on which pc, with what method keys (or other actions) are send.
So <Label w1 Local SendWinM WoW1> defines that when sending a key to the label 'w1' with <SendLabel..> its meant: Sending a key to the window named 'WoW1', which is runing on the local pc using the method SendWinM.

2. Defining a KeyList
This also is a shorter form of defining multiple hotkeys. And basicly means, that all the trigger-keys can be defined in a KeyList and the name of the KeyList can be used in the <HotKey>-definition instead of the triggers. For the syntax see this .

3. Defining the Hotkey

With <Hotkey MyList; Shift MyList; Alt MyList; Ctrl MyList> the triggers for the action defined in the next 2 lines are defined, using the KeyList defined before. The action to execute is composed of 2 things:
a) <SendLabel w1, w2, w3, w4, w5>, tells HKN to which Labels to send (and thereby to wich Window, on which PC with which Method)
b) <Key %Trigger%>, tells HKN what to send. Here the same key as the key which triggerd the action. For reference see: this .

Movement Keys

Some keys which need to be handled differently are keys that should be used for moving, turning etc. in wow, as for them ist not a simple <KeyDown><KeyUp>. This keys can be defined like any other <HotKey> with <MovementHotkey> .
So example code for using the cursor-keys as movement-keys and broadcasting them to all windows, would look like:

<MovementHotkey up, down, left, right>
       	<SendLabel w1, w2, w3, w4, w5>
        	<Key %Trigger%>

Toggeling HKN off/on

Sometimes its quite usefull to simply turn of all hotkey-definitions (for example for chatting) this can be easily be done with defining a Trigger-Key for toggeling HKN on/off like:

<hotkey pause>
	<sendpc local>
	<ToggleHotkeys>

[olipcs]

As HotKeyNet is not restricted on only sending keys, when a hotkey is triggered, but perfom a lot of other actions, it can be used for starting wow itself and renaming the windows.

This can be done like this:

//-----------------------------------------------------------
// SUBROUTINE TO LAUNCH AND RENAME A COPY OF WOW.
//-----------------------------------------------------------
<Command LaunchAndRename>
   <SendPC %1%>
  <Run %2%>
  <RenameTargetWin %3%>
  <RemoveWinFrame>
  <SetAffinity %4%>

//-----------------------------------------------------------
// HOTKEY TO LAUNCH AND RENAME YOUR WOW WINDOWS while 5 boxing
// Please configure the Path and processor afinitys correctly
//-----------------------------------------------------------
<Hotkey Alt Ctrl L>
<LaunchAndRename Local "C:\temp\multi\w1\wow.exe" WoW1 1>
<LaunchAndRename Local "C:\temp\multi\w2\wow.exe" WoW2 2>
<LaunchAndRename Local "C:\temp\multi\w3\wow.exe" WoW3 2>
<LaunchAndRename Local "C:\temp\multi\w4\wow.exe" WoW4 3>
<LaunchAndRename Local "C:\temp\multi\w5\wow.exe" WoW5 3>
<ResizeAndPosition WoW1 WoW2 WoW3 WoW4 WoW5>

This first defines an command (for how to define a command see: this ) named LaunchAndRename, which starts WoW, which has the following parameters:
<LaunchAndRename %1% %2% %3% %4%>
%1%: The pc to to run the WoW from (see <SendPC> )
%2%: path and program to run (This must be customized!) (see <Run> )
%3%: name to rename the window to (see RenameTargetWin )
%4%: Affinity, which processor to use in a dual/quad-core environment (see <SetAffinity> )

Second a <Hotkey> is defined (trigger: ctrl + alt+ l) which uses the command to start 5 wow. And initiates the repositioning and resizing of them with <ResizeAndPositio>. (This is covered in the next paragraph).

[olipcs]

In the steps before you have learned how to setup keybroadcasting and starting the WoWs.
Know we want to position and resize the windows.

This can be done with two commands:

• <SendWin> / <SendWinM> : To specify which window to resize/position
• <SetWinRect x y width heigh> : positions the Window at x,y (x horizontal position, y vertical position)and resizes it to width * heigth (width horizontal size, height vertical size)

So to position the window named 'WoW1' at x=200, y=300 withe the resolution of 640x480 an the local pc you would use the follwoing comand-sequence:

<SendWin WoW1>
 <SetWinRect 200 300 640 480>

derived from this example you can build a command for 5 boxing, by defining five conectional regions and position windows accordingly.
For example for a system using 2 monitos both with a 1280x1024 resolution, and using the first monitor for the 'main' screen, the second monitor for the other four windows, using resolutions of 640x512 for them would look like:

//-----------------------------------------------------------
// SUBROUTINE TO Position Windows for 5 boxing.
//-----------------------------------------------------------
<Command ResizeAndPosition>
   <SendPC Local>
      <SendWinM %1%>
               <SetWinRect 0 0 1280 1024>              
      <SendWinM %2%>
             <SetWinRect 1280 0 640 512>  
        <SendWinM %3%>
            <SetWinRect 1280 512 640 512>     
        <SendWinM %4%>
            <SetWinRect 1920 0 640 512>     
         <SendWinM %5%>
             <SetWinRect 1920 512 640 512>

of course you would have to customize the positions / sizes of the windows as you need them!

[olipcs]

Window-switching

simple window switching, like for example Keyclone does it (even if its called pip there) can be done quite easily with using the selfwritten <ResizeAndPosition>-command shown above.

With this you can do for example simple switching with the trigger-keys F1 - F5 for the corresponding windows WoW1 - WoW5 like this:

//----------------------------------------------------------------
//Window Switching
//----------------------------------------------------------------
<Hotkey F1>
   <ResizeAndPosition WoW1 WoW2 WoW3 WoW4 WoW5>
<Hotkey F2>
   <ResizeAndPosition WoW2 WoW1 WoW3 WoW4 WoW5>
<Hotkey F3>
   <ResizeAndPosition WoW3 WoW2 WoW1 WoW4 WoW5>
<Hotkey F4>
   <ResizeAndPosition WoW4 WoW2 WoW3 WoW1 WoW5>
<Hotkey F5>
   <ResizeAndPosition WoW5 WoW2 WoW3 WoW4 WoW1>

PiP

With HotKeyNet you can do real Picture-in-Picture drawing of windows, like on the following screenshot:


To do this you use the <SetWinPosition> and <SetWinSize>-commands like shown in the above section to resize and position the windows.
But in addition for the 'big window' you specify a 'hole' so that it doesn't overlap the 'littel windows'.

The command to use for this is: <SetWinRegion x y width height> with,

x = relative horizontal position, form the upper left corner of the target window, where the hole should start
y = relative vertical position, form the upper left corner of the target window, where the hole should start
width = horizontal width of th hole
height = vertical height of the hole

So to give an example, image 5boxing on an 1920x1200 screen, and you want the main window to take up the hole screen, and to line up the four 'slave'-windows with a size of 320x200 300 pixels from the bottom, with a spacing of 100px. To switch between them also we use F1-F5. This could be done like this:

<Command ResizeAndPosition>
   <SendPC Local>
       <SendWin %1%>
          <SetWinSize 1920 1200>
          <SetWinPos 0 0>
          <SetWinRegion 160 1620 300 200>
          <SetWinRegion 560 1620 300 200>
          <SetWinRegion 960 1620 300 200>
          <SetWinRegion 1360 1620 300 200>
      <SendWinM %2%>
          <SetWinSize 300 200>
          <SetWinPos 160 1620>     
      <SendWinM %3%>
          <SetWinSize 300 200>
          <SetWinPos 560 1620>     
      <SendWinM %4%>
          <SetWinSize 960 1620>
          <SetWinPos 1920 0>     
     <SendWinM %5%>
           <SetWinSize 1460 1620>
           <SetWinPos 1920 512>

//----------------------------------------------------------------
//Window Switching
//----------------------------------------------------------------
<Hotkey F1>
   <ResizeAndPosition WoW1 WoW2 WoW3 WoW4 WoW5>
<Hotkey F2>
   <ResizeAndPosition WoW2 WoW1 WoW3 WoW4 WoW5>
<Hotkey F3>
   <ResizeAndPosition WoW3 WoW2 WoW1 WoW4 WoW5>
<Hotkey F4>
   <ResizeAndPosition WoW4 WoW2 WoW3 WoW1 WoW5>
<Hotkey F5>
   <ResizeAndPosition WoW5 WoW2 WoW3 WoW4 WoW1>

for an example on HotKeyNEt-site see: this

[olipcs]

With HotKeyNet it is possible to do mouse-broadcasting, meaning that you can broadcast a mouse-click on a position in one window, to the corresponding position (regarding to window-resolution) in anoher window.
In WoW this is quite usefull for 'mouse-healing', using clique or healbot and for using targetet abilities, like blizzard, druids trees, hunter aoe ...

The general command to trigger a mouse-click with hotkey net is <ClickMouse ..> .
The command is quite compley, and better explained in the HKN-APi than i could do it here, so for real details you might look there .

I give here a simple example for simply broadcasting left, right, middle - click while pressing 'g' (for using 'g' as amodifier see <UseKeyAsModifier> ).

<UseKeyAsModifier g>
<Hotkey g LButton, MButton, RButton>  
<SendLabel w1, w2, w3, w4, w5>
<ClickMouse %TriggerMainKey%>

if you want tor also broadcast f.e. shift+left click you would have to add:

<Hotkey g shift LButton, MButton, RButton>  
<SendLabel w1, w2, w3, w4, w5>
<KeyDown shift>
<ClickMouse  %TriggerMainKey%>
<KeyUp shift>

Another example for this can be found here: [HotKeyNet] HotkeyNet + AOE!

[olipcs]

Here only some quick comments/links for how to implement other more advanced features using HotKeyNet.

Round-Robin

Round robin can be implemented using the <Toggle> -command.


For example defining '4' as a round-robin-key for the windows WoW1 - WoW5 can be done like:

<Hotkey 4>
<Toggle>
    <SendLabel w1>
    <Key %trigger%>
   <Toggle>
     <SendLabel w2>
     <Key %trigger%>
   <Toggle>
     <SendLabel w3>
     <Key %trigger%>
   <Toggle>
     <SendLabel w4>
     <Key %trigger%>
   <Toggle>
     <SendLabel w5>
     <Key %trigger%>

Focusless Targetless Leaderless Setup

It is possible to implement an ftl-setup with HotKeyNet, but as it would be a little much to explain it in an introduction thread, i like to only link to the implementation and disscussion:
[HotKeyNet] Implementing an FTL quite simple with templates

Example of an specific implementation:I need a FTL mentor :/ to come

Templates:

In HKN if you have a script-block you want to reuse (with slight modifications) you could use Templates.
To do this, you define templates with <Template> and call them with <ApplyTemplate>.

Remark:
The following I wrote for a user to explain Templates to him, so it might be alittle bit out of context here, but I think to cover some more advanced features of HKN, this could be usefull:


The general idea of templates in HKN is, to give a way to simplify some definitions, that occure quite often, and have a very similar structure.

One relay simple example:

-Lets say you want to define multiple keys (1,2) which sends the key to w1 and always 'w' to w2 (and you don't know about keylists ).

This could be done by defining a Template like:

    
<Template blubb>
     <Sendlabel w1>
        <Key %trigger%>
    <Sendlabel w2>
         <Key w>
<EndTemplate>

and calling it like:

<Hotkey 1>
    <ApplyTemplate blubb>

<Hotkey 2>
    <ApplyTemplate blubb>

What HotkeyNet now does, is simply when finding the '<ApplyTemplate blubb>' look if there a definition for the template with the name 'blubb' specified by <Template blubb> and if it finds such a definition, it substitutes the <ApplyTemplate blubb> with the text defined between <Template blubb> and <EndTemplate>.

So on runtime, the tow Hotkey definitions would look like:

<Hotkey 1>
    <Sendlabel w1>
        <Key %trigger%>
    <Sendlabel w2>
         <Key w>

<Hotkey 2>
        <Sendlabel w1>
        <Key %trigger%>
    <Sendlabel w2>
         <Key w>

This is a real simple working example, but if this would be all templates could do, it wouldn't be so usefull.

The next component of templates are parameters. With parameters you can, when calling a template with <ApplyTemplate> give the call some specific values, which then are used in the template.

For this the calling syntax is:
<ApplyTemplate name parameter1 parameter2 parameter3 ..>

in the Template itself every occurence of %PARAMETER_NUMBER% is than replaced with the text for the parameter.

Short example:
<ApplyTemplate test This is a test>

in the Template specified by <Template test> every occurence of:
- %1% is replaced with This
- %2% is replaced with is
- %3% is replaced with a
- %4% is replaced with test

so the following

<Template sendkey>
   <Hotkey %1%>
       <SendLabel %2%>
             <Key %3%>
<EndTemplate>

<ApplyTemplate 1 w1 u>

would create the following Hotkey:

<Hotkey 1>
   <Sendlabel w1>
       <Key u>

Now, one last important thing:
Normaly HKN seperates parameters by a space.
If you want to use a phrase as an Parameter which containes spaces (like f.e. a path) you have to capsulate it in "" like "This is a test".

So to come back to the original code:
<Template If>
<If MouseIsOverWindowRect %1% %2%>
<SendLabel %3%>
<Key %4%>
<EndTemplate>
<Template Else>
<If MouseIsOverWindowRect %1% %2%>
<SendLabel %3%>
<Key %4%>
<EndTemplate>

<Hotkey ScrollLockOn LButton>
<ApplyTemplate If "WoW5" "88 299 125 58" "w3" "Numpad1">
<ApplyTemplate ElseIf "WoW5" "88 367 125 58" "w3" "Numpad2">
<ApplyTemplate ElseIf "WoW5" "88 433 125 58" "w3" "Numpad3">
<Else>
<SendFocusWin>
<ClickMouse down %Trigger%>
Lets have a look at what <ApplyTemplate If "WoW5" "88 299 125 58" "w3" "Numpad1"> does:

it replaces the <ApplayTemplate If ...> with the block between <Template If> and <EndTemplate> and substitutes:
- %1% with WoW5
- %2% with 88 299 125 58
- %3% with w3
- %4% with Numpad1

So the code in HKN would look like:
<Hotkey ScrollLockOn LButton>
<If MouseIsOverWinRect WoW5 88 299 125 58>
<Sendlabel w3>
<Key Numpad1>
<ApplyTemplate ElseIf "WoW5" "88 367 125 58" "w3" "Numpad2">
<ApplyTemplate ElseIf "WoW5" "88 433 125 58" "w3" "Numpad3">
<Else>
<SendFocusWin>
<ClickMouse down %Trigger%>

( And of course <ApplyTemplate ElseIf ..> would then be replaced with the text of <Template ElseIf> )

[olipcs]

Allmost everything I presented here can be found on the HKN-Website,
so if you realy want to know it go to:

• www.hotkeynet.com
• WoW Quickstart with HKN
• WoW Forum on HotKeyNet.com

[Freddie]

This is terrific!