AutoHotkey Community

[Triggers]
`mail=mymail@server.com
btw=by the way
otoh=on the other hand
plz=please

SetTimer, AutoReplace, on
SetBatchLines, 10ms

;_______Building shortcut text list

Trigger0 = 1
Loop, Read, %a_scriptdir%\Triggers.ini
{
        IfEqual, A_Index, 1, Continue
        StringGetPos, EqPos, A_LoopReadLine, =
        StringLeft, CT, A_LoopReadLine, %EqPos%
        Trigger%A_Index% = %CT%
        Triggers = %Triggers%`,%CT%
        Trigger0 ++
}
;___________________________________________

;___________________________________________
;_____Shortcut text_________________________

AutoReplace:
        SetTimer, AutoReplace, off
        SetKeyDelay, -1
       
        ;more specific trigger texts can be added here:
        Input, UserInput, *V, {ESC}{ENTER}, %Triggers%
       
        Loop, %Trigger0%
        {
                IfEqual, A_Index, 1, Continue
                StringTrimRight, CT, Trigger%A_Index%, 0
                IfInString, UserInput, %CT%
                {
                        StringLen, Tlen, CT
                        IniRead, ToSend, %a_scriptdir%\Triggers.ini, Triggers, %CT%
                        StringReplace, ToSend, ToSend, <s>, %a_space%, A
                        IfNotEqual, ToSend, ERROR, Send, {BS %Tlen%}%ToSend%
                        Break
                }
        }
       
        SetTimer, AutoReplace, on
Return

#SingleInstance  ; Allow only one instance of the script to exist at a time.
SetBatchLines, 10ms  ; Make the script run fast but cooperatively.
SetKeyDelay, 0   ; Make keys get sent faster.

Gosub, InitTriggerList


~[::  ; This is the hotkey that starts us waiting for the user to type a triggering phrase.
TriggerStartTime = %A_TickCount%
TriggerPhrase =
TriggerPhraseLength = 0
Loop
   Gosub, GetNextChar  ; This will Exit for us when the task is finished.
return



GetNextChar:
Loop  ; Poll the specified keyboard keys every 10 ms to wait for the user to press one.
{
   Loop, parse, TriggerChars ; Check if at this instant, one of the allowed keys is pushed down.
   {
      GetKeyState, down_or_up, %A_LoopField%
      if down_or_up = U
         continue  ; Start a new iteration of this loop.
      ; The user is now pressing a key, so add it to the phrase unless it's backspace:
      if A_LoopField = `b
      {
         if TriggerPhraseLength = 0
         {
            if A_OSType = WIN32_WINDOWS  ; Windows 9x
               continue  ; Ignore backspaces if there are no chars in the phrase yet.
            ; Otherwise, the user has just backspaced over the triggering key,
            ; indicating that no triggering action is desired:
            Exit
         }
         ; Otherwise, have a backspace keystroke remove the most recent char in the phrase:
         --TriggerPhraseLength
         StringLeft, TriggerPhrase, TriggerPhrase, %TriggerPhraseLength%
         ; And now wait for the keystroke to be completed so that the backspace key,
         ; which the user is holding down, won't immediately be detected as a 2nd
         ; backspace during the next loop iteration:
         KeyUp = `b
         Gosub, WaitForKeyUp
         continue  ; Start a new iteration of this loop.
      }
      TriggerPhrase = %TriggerPhrase%%A_LoopField%
      ++TriggerPhraseLength
      ; Does the phrase now match one of the triggers in the list?
      if Trigger%TriggerPhrase% <>  ; Match found.
      {
         StringTrimLeft, ReplacementText, Trigger%TriggerPhrase%, 0  ; Retrieve the list item.
         Send, {backspace %TriggerPhraseLength%}

         ; If the OS is Windows 9x, the passthrough (~) nature of the hotkey won't work,
         ; which means that the triggering character itself will always be suppressed.
         ; So here we send an extra backspace when the OS is NT/2k/XP or beyond.
         if A_OSType <> WIN32_WINDOWS  ; i.e. it's not Windows 9x
            Send, {backspace}
         Send, %ReplacementText%
         Exit ; terminate this thread completely because we're done.
      }
      ; Otherwise, there's no match.  So if the phrase is now at its max allowed length, there
      ; is no match.  The below uses "greater than" to allow one extra keypress in case the last
      ; character is a typo and the user wants to salvage the sequence by pressing backspace:
      if TriggerPhraseLength > %MaxTriggerPhraseLength%
      {
         ; Seems better to do nothing so that the triggering key can be used normally:
         ;Send, {backspace %TriggerPhraseLength%}<invalid>
         Exit
      }
      ; Otherwise, wait for more keys.  But first wait for the user to release the current key
      ; so that this key isn't immediately detected as the next key also:
      KeyUp = %A_LoopField%
      Gosub, WaitForKeyUp
      return
   }
   Sleep, 10  ; Allow the CPU to rest between polls (doesn't much degrade reliability or responsiveness).
   TriggerElapsedTime = %A_TickCount%
   TriggerElapsedTime -= %TriggerStartTime%
   if TriggerElapsedTime > %TriggerTimeout%
      Exit  ; Terminate this thread for performance reasons.
}
return



WaitForKeyUp:
Loop
{
   GetKeyState, down_or_up, %KeyUp%
   if down_or_up = U
      return
   Sleep, 10
}
return



InitTriggerList:
; Here list all the characters that would ever exist in a triggering phrase.
; Not that these are not case sensitive because both upper and lower case letters will be detected.
; Note that backspace (`b) is also in the list so that it can be detected as an "undo" character.
TriggerChars = abcdefghijklmnopqrstuvwxyz0123456789`b

; This is the length of the largest triggering abbreviation defined in the list below:
MaxTriggerPhraseLength = 3

; How many milliseconds to wait for the user to complete a triggering phrase before timing out:
TriggerTimeout = 5000

; USA states:
TriggerAL = Alabama
TriggerAK = Alaska
TriggerAZ = Arizona
TriggerAR = Arkansas
TriggerCA = California
TriggerCO = Colorado
TriggerCT = Connecticut
TriggerDE = Delaware
TriggerDC = District of Columbia
TriggerFL = Florida
TriggerGA = Georgia
TriggerHI = Hawaii
TriggerID = Idaho
TriggerIL = Illinois
TriggerIN = Indiana
TriggerIA = Iowa
TriggerKS = Kansas
TriggerKY = Kentucky
TriggerLA = Louisiana
TriggerME = Maine
TriggerMD = Maryland
TriggerMA = Massachusetts
TriggerMI = Michigan
TriggerMN = Minnesota
TriggerMS = Mississippi
TriggerMO = Missouri
TriggerMT = Montana
TriggerNE = Nebraska
TriggerNV = Nevada
TriggerNH = New Hampshire
TriggerNJ = New Jersey
TriggerNM = New Mexico
TriggerNY = New York
TriggerNC = North Carolina
TriggerND = North Dakota
TriggerOH = Ohio
TriggerOK = Oklahoma
TriggerOR = Oregon
TriggerPA = Pennsylvania
TriggerRI = Rhode Island
TriggerSC = Sourth Carolina
TriggerSD = South Dakota
TriggerTN = Tennessee
TriggerTX = Texas
TriggerUT = Utah
TriggerVT = Vermont
TriggerVA = Virginia
TriggerWA = Washington
TriggerWV = West Virginia
TriggerWI = Wisconsin
TriggerWY = Wyoming

; Countries:
TriggerUK = United Kingdom

; Misc:
TriggerAHK = AutoHotkey
return