Multi-Function MButton Hotkey For Caret & Cursor Control (discontinued).ahk

#Requires AutoHotkey 2.0
#Include <UIA> ; Download and unzip archive in "Lib" folder: https://github.com/Descolada/UIA-v2/blob/main/Lib/UIA.ahk

; TODO: make cursor auto-hide for notepad, Visual Studio & VS Code
; THIS MIGHT BE WAY BETTER (TO ADDRESS THE ISSUES MENTIONED BELOW), MAKING THE CURSOR AUTO-HIDE BY DEFAULT WHILE ONE OF THE 3 APPS ARE ACTIVE AND THEN HAVING LONG-PRESS TO TEMPORARILY DISABLE THE CURSOR AUTO-HIDE (AND IT CAN REENABLE IT AFTERWARDS, BUT REACTIVATING THE WINDOW WILL REENABLE IT AUTOMATICALLY). COULD PERHAPS ALSO CHECK IF THE EDIT CONTROL IS FOCUSED (MAYBE EVEN BY USING `editControlElement.GetRuntimeId()` ALTHOUGH COULD ALSO JUST MAKE IT WORK FOR ALL EDIT CONTROLS BY USING THE CLASSNAME OR SOMETHING), IF IT ISN'T THEN TEMPORARILY SHOW THE CURSOR (INSTEAD OF IT BEING DEPENDANT ON THE WINDOW BEING ACTIVE)

; USE THIS IN NOTEPAD ONLY
;MButton::WinActivate("ahk_class Progman")

; USE THIS IN VS CODE ONLY
;MButton::Send("{Alt}")

; USE THIS IN VISUAL STUDIO ONLY (THIS IS THE OLD VERSION, I GOT A BETTER VERSION AS WELL)
; TODO: take temporary screenshot, show screenshot in GUI, (maybe activate VS if it doesn't work w/o doing so), make VS invisible, use workaround below, make VS visible & remove GUI
MButton::
{
    static toggle := false

    if (toggle := !toggle)
    {
        A_CoordModeMouse := "Screen"
        A_KeyDelay := -1
        A_MouseDelay := -1
        MouseGetPos(&previousCursorX, &previousCursorY)
        visualStudioElement := UIA.ElementFromHandle("Microsoft Visual Studio ahk_exe devenv.exe")
        thumbOld := visualStudioElement.WaitElement({Type: "Thumb"})
        thumbOldPos := thumbOld.GetPos("Screen")
        ControlSend(zeroWidthSpace := "​") ; This will unintentionally overwrite the redo actions of the current session
        Send("{Ctrl down}")
        ControlSend("z{Home}", thumbOld.ControlId) ; This will undo the caret marker (its pos remains usable by Ctrl+Shift+Backspace) & moves caret to top
        Send("{Ctrl up}")
        thumbNew := visualStudioElement.WaitElement({Type: "Thumb"})
        thumbNewPos := thumbNew.GetPos("Screen")
        ;UIA.GetFocusedElement().ControlClick("WD", 1, "NA") ; Scrolling like this is more precise if it scrolls one line at a time, which it doesn't but Ctrl+DownArrow does^^
        MouseClickDrag("L", thumbNewPos.x + 1, thumbNewPos.y + 1, thumbOldPos.x, thumbOldPos.y, 0) ; Drag the moveable part of the scrollbar to the previous pos
        MouseMove(previousCursorX, previousCursorY, 0)
    }
    else
        Send("^+{Backspace}") ; Moves caret back to the previous pos (where the caret marker had been temporarily placed to make this possible)
}

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; DOESN'T WORK
F1::WinSetTransparent(0, "Microsoft Visual Studio ahk_exe devenv.exe")
F2::WinSetTransparent("Off", "Microsoft Visual Studio ahk_exe devenv.exe")
F3::MsgBox(WinExist("Microsoft Visual Studio ahk_exe devenv.exe"))

/*
[Could also just overwrite the native middle-btn-press scroll hotkey when visual studio is active, b/c nobody uses that scroll feature in visual studio I think]
Maybe nice for the cursor/caret AHK script to toggle it and which will cause the caret's position to be saved and the caret removed until another toggle places it back where it was, and the toggle hotkey will cause the cursor to hide automatically after some time (repeatedly ofc), temporarily showing the cursor again when the cursor moves. And ~*LButton:: will disable it if it was enabled (if I don't want to click then I can just toggle it w/ middle-click but clicking takes care off toggling only the cursor back for you and it can put the caret somewhere depending on where you clicked, so if you didn't click on text then the caret won't appear ofcourse). That works for multiple scenarios and is useful, keep cursor auto-hide enabled until EITHER foreground change OR CLICK HAS HAPPENED. On middle-click it has to skip the first cursor auto-hide delay. 750ms long-press if I merely want the caret gone but preventing the cursor from hiding. So quick-press is a toggle that can even toggle back after double-press/long-press (is convenient), and both double-press and long-press are toggles as well but toggling back with them is only necessary when you want to keep the other one hidden when both were hidden

Recommend in the hotkey remote tooltip and script comment that you shouldn't use Quick-Press to disable two active hide modes at once and then reenabling one of them straight after, because you can simply toggle the one you don't want with either Double-Press or Long-Press directly. I can technically save the startTime in Quick-Press and checking if very little time has elapsed since it was set when Double-Press/Long-Press is used, to warn the user in a traytip. Might be worth considering when everything else works but is probably not needed, since it's quite obvious

[Can try to document this somewhat, such as "quick-press toggles ANY mode back that's currently in effect" and gotta program it properly]:

If you use quick-press by mistake, then quick-press again to undo it or double-press to disable cursor auto-hide while keeping the caret hidden, or if you instead wanted to see the caret but not the cursor then long-press to toggle only the caret back while keeping the cursor hidden

[Yes this is possible but it might be better if
|
double-(quick-)press would merely toggle the cursor auto-hide which then works for multiple scenarios, which is useful; like it can even toggle the cursor back when both the caret and cursor were hidden (by having performed either a quick-press or both double-press and long-press),
|
but if you use double-(quick-)press first and then (single-)quick-press, it should merely disable the cursor auto-hide and not hide the caret (SO IT'S RECOMMENDED TO DO THIS INSTEAD OF DOUBLE-PRESS TWICE), to make it easier to use.
|
However if you use long-press first and then double-(quick-)press it should just cause the cursor to auto-hide on top of the caret already being hidden]
If you use long-press by mistake, then quick-press will disable it again or double-press instead to hide the cursor on top of the already hidden caret,
|
or if you instead only wanted to hide the cursor then quick-press once to disable it and then double-press (THERE MIGHT BE AN ISSUE IF IT THINKS DOUBLE-PRESS OCCURRED FIRST OR THE THIRD PRESS BEING IGNORED, SO I'M PRETTY SURE IT NEEDS TO DETECT A TRIPLE-PRESS FOR THIS AS WELL, THEN EITHER THE USER DELAYS THE DOUBLE-CLICK AND IT WILL WORK OR THE USER PRESSES 3 TIMES AND IT WILL WORK, IF THE USER DELAYS THE THIRD PRESS THEN IT'S THEIR OWN FAULT, WHICH MOST LIKELY WON'T HAPPEN! AND IF IT DOES THEN IT'S NEGLIGIBLE AND CAN BE EASILY CORRECTED ANYWAY. THEY WOULD SIMPLY EXPECT THE CARET TO BE VISIBLE AND THE CURSOR TO BE GONE BUT BOTH WOULD BE VISIBLE, SO THEN THEY JUST DO ONE MORE QUICK-PRESS. EASY).

If you use long-press to hide the caret and then quick-press, it will show the caret and SHOULDN'T affect the cursor
If you use double-press by mistake, then quick-press will disable it again or long-press to hide the caret on top of the already hidden cursor, or if you instead only wanted to hide the caret then quick-press once to disable it and then long-press (gotta make sure that these two actions don't get detected as a double-press)

Make the double-press and long-press toggle back like described above but also show a traytip if not both were hidden when toggling a specific one back, explaining to the user; title: "Only One Hide Mode Was Active" content: "Quick-Press Disables It Conveniently!"
*/

/*
resetting caret+cursor on left-click (on selection change event is probably overkill, if both caret and cursor get hidden & then the cursor gets shown b/c of left-click but caret didn't..)

remember: `using MButton > clicking another Edit control [> CAN STILL RESET PREV CARET IF REFOCUS PREV EDIT CONTROL HERE] > using MButton again` will overwrite the previous selection

maybe I can check on left-click if the same element is still focused, in which case it shouldn't reset the selection (and if I make the caret + cursor script, then maybe something similar). not the focus change event b/c it won't trigger when different text gets selected
*/

/*
clicking the scrollbar or any non-Edit element (after the MButton hide fn) could be the reason for it not going to work the way it's supposed to

Ik skip voor nu de cursor, ik denk dat de resultaat anders niet echt chill zal zijn om te gebruiken. Dat je 2x moet klikken of lang ingedrukt houden, om dus iets er nog bij te verbergen als je bijvoorbeeld ergens klikt en de cursor weer zichtbaar blijft en je dan dus de cursor opnieuw moet verbergen.. Zelfs als long-press nogal kort is en dus onzichtbaar word tijdens het ingedrukt houden. Is vast beter om gwn de cursor zelf naar rechts te bewegen, ook al komt die dan op een tweede scherm terecht ooit. Je hebt ook VSCode en Notepad waar het dan ws weer anders moet werken enzo. Ander keer misschien proberen
*/

; https://superuser.com/questions/1270165/how-to-remove-the-blinking-caret-and-temporarily-hide-my-cursor-with-a-single-ho

;on WinAPI about caret
;HideCaret        ; DOESN'T SEEM TO WORK
;ShowCaret        ; USELESS B/C THE ONE ABOVE DIDN'T WORK
;CreateCaret
;SetCaretPos

; THESE PROBABLY DO NOT WORK IN MICROSOFT VISUAL STUDIO DUE TO HAVING A SPECIAL EDIT CTRL (`GetCaretPos` BELOW PROBABLY DOES WORK THO)
;EditGetCurrentCol  Returns the column number in an Edit control where the caret (text insertion point) resides
;EditGetCurrentLine Returns the line number in an Edit control where the caret (text insert point) resides

/**
 * Gets the position of the caret with UIA, Acc or CaretGetPos.
 * Credit: plankoe (https://www.reddit.com/r/AutoHotkey/comments/ysuawq/get_the_caret_location_in_any_program/)
 * @param X Value is set to the screen X-coordinate of the caret
 * @param Y Value is set to the screen Y-coordinate of the caret
 * @param W Value is set to the width of the caret
 * @param H Value is set to the height of the caret
 */
GetCaretPos(&X?, &Y?, &W?, &H?) {
    /*
        This implementation prefers CaretGetPos > Acc > UIA. This is mostly due to speed differences
        between the methods and statistically it seems more likely that the UIA method is required the
        least (Chromium apps support Acc as well).
    */
    ; Default caret
    savedCaret := A_CoordModeCaret
    CoordMode "Caret", "Screen"
    CaretGetPos(&X, &Y)
    CoordMode "Caret", savedCaret
    if IsInteger(X) && (X | Y) != 0 {
        W := 4, H := 20
        return
    }

    ; Acc caret
    static _ := DllCall("LoadLibrary", "Str","oleacc", "Ptr")
    try {
        idObject := 0xFFFFFFF8 ; OBJID_CARET
        if DllCall("oleacc\AccessibleObjectFromWindow", "ptr", WinExist("A"), "uint",idObject &= 0xFFFFFFFF
            , "ptr",-16 + NumPut("int64", idObject == 0xFFFFFFF0 ? 0x46000000000000C0 : 0x719B3800AA000C81, NumPut("int64", idObject == 0xFFFFFFF0 ? 0x0000000000020400 : 0x11CF3C3D618736E0, IID := Buffer(16)))
            , "ptr*", oAcc := ComValue(9,0)) = 0 {
            x:=Buffer(4), y:=Buffer(4), w:=Buffer(4), h:=Buffer(4)
            oAcc.accLocation(ComValue(0x4003, x.ptr, 1), ComValue(0x4003, y.ptr, 1), ComValue(0x4003, w.ptr, 1), ComValue(0x4003, h.ptr, 1), 0)
            X:=NumGet(x,0,"int"), Y:=NumGet(y,0,"int"), W:=NumGet(w,0,"int"), H:=NumGet(h,0,"int")
            if (X | Y) != 0
                return
        }
    }

    ; UIA caret
    static IUIA := ComObject("{e22ad333-b25f-460c-83d0-0581107395c9}", "{34723aff-0c9d-49d0-9896-7ab52df8cd8a}")
    try {
        ComCall(8, IUIA, "ptr*", &FocusedEl:=0) ; GetFocusedElement
        /*
            The current implementation uses only TextPattern GetSelections and not TextPattern2 GetCaretRange.
            This is because TextPattern2 is less often supported, or sometimes reports being implemented
            but in reality is not. The only downside to using GetSelections is that when text
            is selected then caret position is ambiguous. Nevertheless, in those cases it most
            likely doesn't matter much whether the caret is in the beginning or end of the selection.

            If GetCaretRange is needed then the following code implements that:
            ComCall(16, FocusedEl, "int", 10024, "ptr*", &patternObject:=0), ObjRelease(FocusedEl) ; GetCurrentPattern. TextPattern2 = 10024
            if patternObject {
                ComCall(10, patternObject, "int*", &IsActive:=1, "ptr*", &caretRange:=0), ObjRelease(patternObject) ; GetCaretRange
                ComCall(10, caretRange, "ptr*", &boundingRects:=0), ObjRelease(caretRange) ; GetBoundingRectangles
                if (Rect := ComValue(0x2005, boundingRects)).MaxIndex() = 3 { ; VT_ARRAY | VT_R8
                    X:=Round(Rect[0]), Y:=Round(Rect[1]), W:=Round(Rect[2]), H:=Round(Rect[3])
                    return
                }
            }
        */
        ComCall(16, FocusedEl, "int", 10014, "ptr*", &patternObject:=0), ObjRelease(FocusedEl) ; GetCurrentPattern. TextPattern = 10014
        if patternObject {
            ComCall(5, patternObject, "ptr*", &selectionRanges:=0), ObjRelease(patternObject) ; GetSelections
            ComCall(4, selectionRanges, "int", 0, "ptr*", &selectionRange:=0) ; GetElement
            ComCall(10, selectionRange, "ptr*", &boundingRects:=0), ObjRelease(selectionRange), ObjRelease(selectionRanges) ; GetBoundingRectangles
            if (Rect := ComValue(0x2005, boundingRects)).MaxIndex() = 3 { ; VT_ARRAY | VT_R8
                X:=Round(Rect[0]), Y:=Round(Rect[1]), W:=Round(Rect[2]), H:=Round(Rect[3])
                return
            }
        }
    }
}

OnExit (*) => SystemCursor("Show")  ; Ensure the cursor is made visible when the script exits.

#c::SystemCursor("Toggle")  ; Win+C hotkey to toggle the cursor on and off.

SystemCursor(cmd) ; cmd = "Show|Hide|Toggle|Reload"
{
    static visible := true, c := Map()
    static sys_cursors := [32512, 32513, 32514, 32515, 32516, 32642, 32643, 32644, 32645, 32646, 32648, 32649, 32650]

    if (cmd = "Reload" || !c.Count) ; Reload when requested or at first call
    {
        for (i, id in sys_cursors)
        {
            h_cursor  := DllCall("LoadCursor", "Ptr", 0, "Ptr", id)
            h_default := DllCall("CopyImage", "Ptr", h_cursor, "UInt", 2, "Int", 0, "Int", 0, "UInt", 0)
            h_blank   := DllCall("CreateCursor", "Ptr", 0, "Int", 0, "Int", 0, "Int", 32, "Int", 32, "Ptr", Buffer(32 * 4, 0xFF), "Ptr", Buffer(32 * 4, 0))
            c[id] := {Default: h_default, Blank: h_blank}
        }
    }

    switch (cmd)
    {
        case "Show": visible := true
        case "Hide": visible := false
        case "Toggle": visible := !visible
        default: return
    }

    for (id, handles in c)
    {
        h_cursor := DllCall("CopyImage", "Ptr", visible ? handles.Default : handles.Blank, "UInt", 2, "Int", 0, "Int", 0, "UInt", 0)
        DllCall("SetSystemCursor", "Ptr", h_cursor, "UInt", id)
    }
}