Отслеживание мышки

import * as Frame from '../../FrameExt'
import { Color, Vec2 } from '../../Utils'

const COLOR = new Color(0, 0, 0, 0.1)

export class MouseDetectGrid extends Frame.SimpleEmpty {
    constructor(cols: number, rows: number){
        super()
        
        this.__grid_btn = []
        this.__grid_tool = []
        for (let x = 0; x < cols; x++){
            this.__grid_btn.push([])
            this.__grid_tool.push([])
            for (let y = 0; y < rows; y++){
                let btn = new Frame.GlueTextButton()
                this.__grid_btn[x].push(btn)
                btn.parent = this
                btn.color = COLOR

                let tool = new Frame.Backdrop()
                this.__grid_tool[x].push(tool)
                tool.visible = false
                tool.color = new Color(0, 0, 0, 0)
                BlzFrameSetTooltip(btn.handle, tool.handle)
            }
        }
    }

    getMousePos(){
        for (let x = 0; x < this.__grid_btn.length; x++){
            for (let y = 0; y < this.__grid_btn[x].length; y++){
                let tool = this.__grid_tool[x][y]
                if (tool.visible){
                    let btn = this.__grid_btn[x][y]
                    return $multi(true, this.pos.add(btn.pos), btn.size)
                }
            }
        }
        return $multi(false, this.pos, this.size)
    }

    protected _set_size(size: Vec2){
        super._set_size(size)

        let btn_size = new Vec2(size.x / this.__grid_btn.length,
                                size.y / this.__grid_btn[0].length)
        for (let x = 0; x < this.__grid_btn.length; x++){
            for (let y = 0; y < this.__grid_btn[x].length; y++){
                this.__grid_btn[x][y].size = btn_size
                this.__grid_btn[x][y].pos = new Vec2(x * btn_size.x, y * btn_size.y)
            }
        }

    }

    private __grid_btn: Frame.GlueTextButton[][]
    private __grid_tool: Frame.Backdrop[][]
}

import * as Frame from '../../FrameExt'
import { hTimer } from '../../Handle'
import { Vec2 } from '../../Utils'

import { MouseDetectGrid } from './Grid'

const STEP_TIME = 0.025
const GRID_SIZE = 8
const ROI_SIZE = 3

export class MouseDetector {
    constructor(){
        this.precision = 0.01
        this.__pos = Frame.Screen.pos
        this.__size = Frame.Screen.size

        this.__grid = new MouseDetectGrid(GRID_SIZE, GRID_SIZE)

        let t = new hTimer()
        t.addAction(() => {
            this.__pos = Frame.Screen.pos
            this.__size = Frame.Screen.size
            this.__grid.pos = this.__pos
            this.__grid.size = this.__size
            this.__getBetterPos()
        })

        let period = STEP_TIME
        let tmp = this.precision
        while (tmp < Frame.Screen.size.x){
            tmp *= GRID_SIZE / ROI_SIZE
            period += STEP_TIME
        }

        t.start(period, true)
    }

    getMouse(){
        return this.__pos
    }

    private __getBetterPos(){
        let t = new hTimer()
        t.addAction(() => {
            t.destroy()
            let found: boolean
            [found, this.__pos, this.__size] = this.__grid.getMousePos()

            if (!found){
                return
            }

            this.__grid.pos = this.__pos.sub(this.__size.mult((ROI_SIZE - 1) / 2))
            this.__grid.size = this.__size.mult(ROI_SIZE)

            print(this.__pos.toString(), this.__size.toString())

            if (this.__size.x > this.precision || this.__size.y > this.precision){
                this.__getBetterPos()
            }
        })
        t.start(STEP_TIME, false)
    }

    precision: number

    private __pos: Vec2
    private __size: Vec2

    private __grid: MouseDetectGrid
}

local Screen = {}

Screen.pos = {0, 0}
Screen.size = {0.8, 0.6}

local pixel_w = 0
local pixel_h = 0

local function update()
    local cur_pixel_width = BlzGetLocalClientWidth()
    local cur_pixel_height = BlzGetLocalClientHeight()

    if (cur_pixel_width == pixel_w and cur_pixel_height == pixel_h) then
        return
    end

    pixel_w = cur_pixel_width
    pixel_h = cur_pixel_height

    local default_zone_width = cur_pixel_height * 0.8 / 0.6
    Screen.size[0] = 0.8 * cur_pixel_width / default_zone_width
    Screen.pos[0] = - (Screen.__size.x - 0.8) / 2
end

local timer = CreateTimer()
TimerStart(timer, 1, true, update)
update()

return Screen

local Grid = {}

local COLS = 7
local ROWS = 7

local __pos = {0, 0}
local __size = {0, 0}
local btns = {}
local tools = {}

local parent = BlzGetFrameByName("ConsoleUIBackdrop", 0)

for x = 1, COLS do
    btns[x] = {}
    tools[x] = {}
    for y = 1, ROWS do
        btns[x][y] = BlzCreateFrameByType("GLUETEXTBUTTON", "MyButton", parent, "ScriptDialogButton", 0)
        BlzFrameSetAlpha(btns[x][y], 25)
        BlzFrameSetAbsPoint(btns[x][y], FRAMEPOINT_BOTTOMLEFT, 0, 0)
        BlzFrameSetSize(btns[x][y], 0, 0)

        tools[x][y] = BlzCreateFrameByType("FRAME", "FaceFrame", parent, "", 0)
        BlzFrameSetAlpha(tools[x][y], 0)
        BlzFrameSetAbsPoint(tools[x][y], FRAMEPOINT_BOTTOMLEFT, 0, 0)
        BlzFrameSetSize(tools[x][y], 0, 0)

        BlzFrameSetTooltip(btns[x][y], tools[x][y])
    end
end

local function __updateGrid()
    local w = __size[0] / COLS
    local h = __size[1] / ROWS

    for x = 1, COLS do
        for y = 1, ROWS do
            BlzFrameSetAbsPoint(btns[x][y], FRAMEPOINT_BOTTOMLEFT, __pos[0] + x * w, __pos[1] + y * h)
        end
    end
end

function Grid.setPos(pos)
    __pos = pos
    __updateGrid()
end

function Grid.setSize(size)
    __size = size
    __updateGrid()
end

-- return true, x, y, w, h
-- return false
function Grid.mouseROI()
    local w = __size[0] / COLS
    local h = __size[1] / ROWS

    for x = 1, COLS do
        for y = 1, ROWS do
            local found = BlzFrameIsVisible(tools[x][y])
            if (found) then
                return true, __pos[0] + x * w, __pos[1] + y * h, w, h
            end
        end
    end

    return false
end

return Grid

local Screen = require('Screen')
local Grid = require('Grid')

local Detector = {}

local timer = CreateTimer()

local ROI = 3
local PREC = 0.01

Detector.x = 0
Detector.y = 0
Detector.w = 0
Detector.h = 0

local function __getBetterPos()
    local t = CreateTimer()
    TimerStart(t, 0.025, false, function()
        DestroyTimer(t)

        local found, x, y, w, h = Grid.mouseROI()
        Detector.x = x
        Detector.y = y
        Detector.w = w
        Detector.h = h
        if (not found) then
            return
        end

        if (w > PREC or h > PREC) then
            __getBetterPos()
        end

        Grid.setPos({x - w * (ROI - 1) / 2, y - h * (ROI - 1) / 2})
        Grid.setSize({w * ROI, h * ROI})
    end)
end

local timer = CreateTimer()
TimerStart(t, 0.5, true, function()
    Detector.x = Screen.pos[0]
    Detector.y = Screen.pos[1]
    Detector.w = Screen.size[0]
    Detector.h = Screen.size[1]
    __getBetterPos()
end)

return Detector