warscript 0.0.1-dev.404878c

package/core/types/frame.lua

@@ -0,0 +1,882 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__New = ____lualib.__TS__New
+local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local ____exports = {}
+local leftBorderFrame, rightBorderFrame
+local ____handle = require("core.types.handle")
+local Handle = ____handle.Handle
+local ____player = require("core.types.player")
+local Player = ____player.Player
+local ____event = require("event")
+local Event = ____event.Event
+local TriggerEvent = ____event.TriggerEvent
+local ____timer = require("core.types.timer")
+local Timer = ____timer.Timer
+local frameClick = BlzFrameClick
+local frameGetEnable = BlzFrameGetEnable
+local frameIsVisible = BlzFrameIsVisible
+local frameSetEnable = BlzFrameSetEnable
+local frameSetScale = BlzFrameSetScale
+local getCameraTargetPositionX = GetCameraTargetPositionX
+local getCameraTargetPositionY = GetCameraTargetPositionY
+local ____rawget = _G.rawget
+local rawset = _G.rawset
+local invoke = Event.invoke
+local FrameEvent = __TS__Class()
+FrameEvent.name = "FrameEvent"
+__TS__ClassExtends(FrameEvent, TriggerEvent)
+function FrameEvent.prototype.____constructor(self, frame, eventType, c)
+    TriggerEvent.prototype.____constructor(
+        self,
+        function(trigger) return BlzTriggerRegisterFrameEvent(trigger, frame.handle, eventType) end,
+        c
+    )
+    frame.destroyEvent:addListener(function()
+        self:destroy()
+    end)
+end
+FrameEvent.playerCollector = function()
+    return Player:of(GetTriggerPlayer())
+end
+local consoleUIBackdrop = BlzGetFrameByName("ConsoleUIBackdrop", 0)
+local leftBorder = BlzCreateFrameByType(
+    "FRAME",
+    "LeftBorderFrame",
+    consoleUIBackdrop,
+    "",
+    0
+)
+local rightBorder = BlzCreateFrameByType(
+    "FRAME",
+    "RightBorderFrame",
+    consoleUIBackdrop,
+    "",
+    0
+)
+local function updateBorders()
+    local w = BlzGetLocalClientWidth()
+    local h = BlzGetLocalClientHeight()
+    local width4by3 = (w - h / 600 * 800) / 2
+    local pxtodpi = 0.6 / h
+    BlzFrameSetAbsPoint(leftBorder, FRAMEPOINT_TOPLEFT, -width4by3 * pxtodpi, 0.6)
+    BlzFrameSetSize(leftBorder, 0.001, 0.6)
+    BlzFrameSetAbsPoint(rightBorder, FRAMEPOINT_TOPRIGHT, (-width4by3 + w) * pxtodpi, 0.6)
+    BlzFrameSetSize(rightBorder, 0.001, 0.6)
+end
+local worldFrame = BlzGetOriginFrame(ORIGIN_FRAME_WORLD_FRAME, 0)
+local worldFrameTooltip = BlzCreateFrameByType(
+    "FRAME",
+    "WorldFrameTooltip",
+    worldFrame,
+    "",
+    0
+)
+BlzFrameSetTooltip(worldFrame, worldFrameTooltip)
+local dummyButtonOn = BlzCreateFrameByType(
+    "BUTTON",
+    "DummyButton",
+    worldFrame,
+    "",
+    0
+)
+local dummyButtonOff = BlzCreateFrameByType(
+    "BUTTON",
+    "DummyButton",
+    worldFrame,
+    "",
+    0
+)
+local syncTrigger = CreateTrigger()
+BlzTriggerRegisterFrameEvent(syncTrigger, dummyButtonOn, FRAMEEVENT_CONTROL_CLICK)
+BlzTriggerRegisterFrameEvent(syncTrigger, dummyButtonOff, FRAMEEVENT_CONTROL_CLICK)
+local isMouseOnZeroSync = {}
+local isMouseOnWorld = BlzFrameIsVisible(worldFrameTooltip)
+local isMouseOnWorldSync = {}
+TriggerAddAction(
+    syncTrigger,
+    function()
+        isMouseOnWorldSync[GetPlayerId(GetTriggerPlayer())] = BlzGetTriggerFrame() == dummyButtonOn
+    end
+)
+Timer.onPeriod[1 / 64]:addListener(function()
+    if frameIsVisible(worldFrameTooltip) ~= isMouseOnWorld then
+        isMouseOnWorld = not isMouseOnWorld
+        frameClick(isMouseOnWorld and dummyButtonOn or dummyButtonOff)
+    end
+end)
+____exports.FramePoint = {}
+local FramePoint = ____exports.FramePoint
+do
+    FramePoint.TOP_LEFT = FRAMEPOINT_TOPLEFT
+    FramePoint.TOP = FRAMEPOINT_TOP
+    FramePoint.TOP_RIGHT = FRAMEPOINT_TOPRIGHT
+    FramePoint.LEFT = FRAMEPOINT_LEFT
+    FramePoint.CENTER = FRAMEPOINT_CENTER
+    FramePoint.RIGHT = FRAMEPOINT_RIGHT
+    FramePoint.BOTTOM_LEFT = FRAMEPOINT_BOTTOMLEFT
+    FramePoint.BOTTOM = FRAMEPOINT_BOTTOM
+    FramePoint.BOTTOM_RIGHT = FRAMEPOINT_BOTTOMRIGHT
+end
+____exports.Frame = __TS__Class()
+local Frame = ____exports.Frame
+Frame.name = "Frame"
+__TS__ClassExtends(Frame, Handle)
+function Frame.prototype.____constructor(self, ...)
+    Handle.prototype.____constructor(self, ...)
+    self.hideCounter = 0
+    self.disableCounter = 0
+end
+function Frame.isMouseOnWorld(self, player)
+    if player then
+        return (isMouseOnWorldSync[player.id] or false) and not isMouseOnZeroSync[player.id]
+    end
+    return BlzFrameIsVisible(worldFrameTooltip) and not isMouseOnZeroSync[Player["local"].id]
+end
+function Frame.prototype.onDestroy(self)
+    BlzDestroyFrame(self.handle)
+    return Handle.prototype.onDestroy(self)
+end
+function Frame.prototype.getEvent(self, eventType, c)
+    self.events = self.events or ({})
+    local eventId = GetHandleId(eventType)
+    if not self.events[eventId] then
+        self.events[eventId] = __TS__New(
+            FrameEvent,
+            self,
+            eventType,
+            c and (function() return Player:of(GetTriggerPlayer()), c() end) or FrameEvent.playerCollector
+        )
+    end
+    return self.events[eventId]
+end
+function Frame.prototype.hide(self)
+    self.hideCounter = self.hideCounter + 1
+    if self.hideCounter > 0 then
+        BlzFrameSetVisible(self.handle, false)
+    end
+end
+function Frame.prototype.show(self)
+    self.hideCounter = self.hideCounter - 1
+    if self.hideCounter <= 0 then
+        self.hideCounter = 0
+        BlzFrameSetVisible(self.handle, true)
+    end
+end
+function Frame.prototype.disable(self)
+    self.disableCounter = self.disableCounter + 1
+    if self.disableCounter > 0 then
+        frameSetEnable(self.handle, false)
+        local onDisable = ____rawget(self, "onDisable")
+        if onDisable ~= nil then
+            invoke(onDisable)
+        end
+    end
+end
+function Frame.prototype.enable(self)
+    self.disableCounter = self.disableCounter - 1
+    if self.disableCounter <= 0 then
+        self.disableCounter = 0
+        frameSetEnable(self.handle, true)
+        local onEnable = ____rawget(self, "onEnable")
+        if onEnable ~= nil then
+            invoke(onEnable)
+        end
+    end
+end
+function Frame.prototype.addText(self, text)
+    BlzFrameAddText(self.handle, text)
+end
+function Frame.prototype.clearAllPoints(self)
+    BlzFrameClearAllPoints(self.handle)
+end
+function Frame.prototype.getChild(self, index)
+    return ____exports.Frame:of(BlzFrameGetChild(self.handle, index))
+end
+function Frame.prototype.getChildrenCount(self)
+    return BlzFrameGetChildrenCount(self.handle)
+end
+function Frame.prototype.setSize(self, width, height)
+    BlzFrameSetSize(self.handle, width, height)
+end
+function Frame.prototype.setPoint(self, point, relative, relativePoint, x, y)
+    BlzFrameSetPoint(
+        self.handle,
+        point,
+        relative.handle,
+        relativePoint,
+        x,
+        y
+    )
+end
+function Frame.prototype.setAbsPoint(self, point, x, y)
+    BlzFrameSetAbsPoint(self.handle, point, x, y)
+end
+function Frame.prototype.setAllPoints(self, other)
+    BlzFrameSetAllPoints(self.handle, other.handle)
+end
+function Frame.prototype.setFont(self, filename, height, flags)
+    BlzFrameSetFont(self.handle, filename, height, flags)
+end
+function Frame.prototype.setTexture(self, filename, flag, blend)
+    BlzFrameSetTexture(self.handle, filename, flag, blend)
+end
+function Frame.prototype.setTextAlignment(self, vert, horz)
+    BlzFrameSetTextAlignment(self.handle, vert, horz)
+end
+function Frame.prototype.setVertexColor(self, color)
+    BlzFrameSetVertexColor(
+        self.handle,
+        BlzConvertColor(color.a, color.r, color.g, color.b)
+    )
+end
+function Frame.prototype.setTextColor(self, color)
+    BlzFrameSetTextColor(
+        self.handle,
+        BlzConvertColor(color.a, color.r, color.g, color.b)
+    )
+end
+function Frame.prototype.setTooltip(self, tooltip)
+    BlzFrameSetTooltip(self.handle, tooltip.handle)
+end
+function Frame.prototype.setMinMaxValue(self, minValue, maxValue)
+    BlzFrameSetMinMaxValue(self.handle, minValue, maxValue)
+end
+function Frame.prototype.setStepSize(self, stepSize)
+    BlzFrameSetStepSize(self.handle, stepSize)
+end
+function Frame.prototype.setFocus(self, flag)
+    BlzFrameSetFocus(self.handle, flag)
+end
+function Frame.prototype.resetFocus(self)
+    if BlzFrameGetEnable(self.handle) then
+        BlzFrameSetEnable(self.handle, false)
+        BlzFrameSetEnable(self.handle, true)
+    end
+end
+function Frame.prototype.click(self)
+    BlzFrameClick(self.handle)
+end
+function Frame.createSimple(self, name, parent, createContext)
+    return self:of(BlzCreateSimpleFrame(
+        name,
+        parent and parent.handle or BlzGetOriginFrame(ORIGIN_FRAME_SIMPLE_UI_PARENT, 0),
+        createContext or 0
+    ))
+end
+function Frame.create(self, name, parent, priority, createContext)
+    return self:of(BlzCreateFrame(name, parent.handle, priority or 0, createContext or 0))
+end
+function Frame.createByType(self, typeName, name, parent, inherits, createContext)
+    return self:of(BlzCreateFrameByType(
+        typeName,
+        name,
+        parent.handle,
+        inherits or "",
+        createContext or 0
+    ))
+end
+function Frame.byName(self, name, context)
+    if context == nil then
+        context = 0
+    end
+    return self:of(BlzGetFrameByName(name, context))
+end
+function Frame.byOrigin(self, frameType, index)
+    if index == nil then
+        index = 0
+    end
+    return self:of(BlzGetOriginFrame(frameType, index))
+end
+Frame.GAME_UI = ____exports.Frame:byOrigin(ORIGIN_FRAME_GAME_UI)
+Frame.CONSOLE_UI = ____exports.Frame:byOrigin(ORIGIN_FRAME_SIMPLE_UI_PARENT)
+Frame.CONSOLE_UI_BACKDROP = ____exports.Frame:byName("ConsoleUIBackdrop")
+Frame.WORLD = ____exports.Frame:byOrigin(ORIGIN_FRAME_WORLD_FRAME)
+Frame.CHAT = ____exports.Frame:byOrigin(ORIGIN_FRAME_CHAT_MSG)
+Frame.TIME_OF_DAY_CLOCK = ____exports.Frame.GAME_UI:getChild(5):getChild(0)
+__TS__ObjectDefineProperty(
+    Frame,
+    "leftBorder",
+    {get = function(self)
+        Timer.onPeriod[1 / 64]:addListener(updateBorders)
+        rawset(self, "leftBorder", leftBorderFrame)
+        rawset(self, "rightBorder", rightBorderFrame)
+        return leftBorderFrame
+    end}
+)
+__TS__ObjectDefineProperty(
+    Frame,
+    "rightBorder",
+    {get = function(self)
+        Timer.onPeriod[1 / 64]:addListener(updateBorders)
+        rawset(self, "leftBorder", leftBorderFrame)
+        rawset(self, "rightBorder", rightBorderFrame)
+        return rightBorderFrame
+    end}
+)
+__TS__ObjectDefineProperty(
+    Frame,
+    "minX",
+    {get = function(self)
+        local w = BlzGetLocalClientWidth()
+        local h = BlzGetLocalClientHeight()
+        local width4by3 = (w - h / 600 * 800) / 2
+        local pxtodpi = 0.6 / h
+        return -width4by3 * pxtodpi
+    end}
+)
+__TS__ObjectDefineProperty(
+    Frame,
+    "maxX",
+    {get = function(self)
+        local w = BlzGetLocalClientWidth()
+        local h = BlzGetLocalClientHeight()
+        local width4by3 = (w - h / 600 * 800) / 2
+        local pxtodpi = 0.6 / h
+        return (-width4by3 + w) * pxtodpi
+    end}
+)
+Frame.centerX = 0.4
+Frame.minY = 0
+Frame.maxY = 0.6
+Frame.centerY = 0.3
+__TS__SetDescriptor(
+    Frame.prototype,
+    "visible",
+    {
+        get = function(self)
+            return BlzFrameIsVisible(self.handle)
+        end,
+        set = function(self, visible)
+            BlzFrameSetVisible(self.handle, visible)
+            self.hideCounter = visible and 0 or 1
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Frame.prototype,
+    "enabled",
+    {
+        get = function(self)
+            return frameGetEnable(self.handle)
+        end,
+        set = function(self, enabled)
+            if frameGetEnable(self.handle) ~= enabled then
+                frameSetEnable(self.handle, enabled)
+                if enabled then
+                    local onEnable = ____rawget(self, "onEnable")
+                    if onEnable ~= nil then
+                        invoke(onEnable)
+                    end
+                else
+                    local onDisable = ____rawget(self, "onDisable")
+                    if onDisable ~= nil then
+                        invoke(onDisable)
+                    end
+                end
+            end
+            self.disableCounter = enabled and 0 or 1
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Frame.prototype,
+    "parent",
+    {
+        get = function(self)
+            return ____exports.Frame:of(BlzFrameGetParent(self.handle))
+        end,
+        set = function(self, parent)
+            BlzFrameSetParent(self.handle, parent.handle)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Frame.prototype,
+    "text",
+    {
+        get = function(self)
+            return BlzFrameGetText(self.handle)
+        end,
+        set = function(self, text)
+            BlzFrameSetText(self.handle, text)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Frame.prototype,
+    "textSizeLimit",
+    {
+        get = function(self)
+            return BlzFrameGetTextSizeLimit(self.handle)
+        end,
+        set = function(self, size)
+            BlzFrameSetTextSizeLimit(self.handle, size)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Frame.prototype,
+    "value",
+    {
+        get = function(self)
+            return BlzFrameGetValue(self.handle)
+        end,
+        set = function(self, value)
+            BlzFrameSetValue(self.handle, value)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Frame.prototype,
+    "height",
+    {
+        get = function(self)
+            return BlzFrameGetHeight(self.handle)
+        end,
+        set = function(self, height)
+            BlzFrameSetSize(self.handle, self.width, height)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Frame.prototype,
+    "width",
+    {
+        get = function(self)
+            return BlzFrameGetWidth(self.handle)
+        end,
+        set = function(self, width)
+            BlzFrameSetSize(self.handle, width, self.height)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Frame.prototype,
+    "alpha",
+    {
+        get = function(self)
+            return BlzFrameGetAlpha(self.handle)
+        end,
+        set = function(self, alpha)
+            BlzFrameSetAlpha(self.handle, alpha)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Frame.prototype,
+    "scale",
+    {
+        get = function(self)
+            return self._scale or 1
+        end,
+        set = function(self, v)
+            frameSetScale(self.handle, v)
+            self._scale = v ~= 1 and v or nil
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Frame.prototype,
+    "name",
+    {get = function(self)
+        return BlzFrameGetName(self.handle)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Frame.prototype,
+    "onClick",
+    {get = function(self)
+        return self:getEvent(FRAMEEVENT_CONTROL_CLICK)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Frame.prototype,
+    "onCheckboxChecked",
+    {get = function(self)
+        return self:getEvent(FRAMEEVENT_CHECKBOX_CHECKED)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Frame.prototype,
+    "onCheckboxUnchecked",
+    {get = function(self)
+        return self:getEvent(FRAMEEVENT_CHECKBOX_UNCHECKED)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Frame.prototype,
+    "onEnter",
+    {get = function(self)
+        return self:getEvent(FRAMEEVENT_EDITBOX_ENTER)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Frame.prototype,
+    "onMouseDoubleClick",
+    {get = function(self)
+        return self:getEvent(FRAMEEVENT_MOUSE_DOUBLECLICK)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Frame.prototype,
+    "onMouseDown",
+    {get = function(self)
+        self.events = self.events or ({})
+        local eventId = GetHandleId(FRAMEEVENT_MOUSE_DOWN)
+        if not self.events[eventId] then
+            local event = __TS__New(Event)
+            self.mouseInside = {}
+            self.onMouseEnter:addListener(function(player)
+                self.mouseInside[player.id] = true
+            end)
+            self.onMouseLeave:addListener(function(player)
+                self.mouseInside[player.id] = false
+            end)
+            Player.onMouseDown:addListener(function(player, button)
+                if self.mouseInside[player.id] then
+                    Event.invoke(event, player, button)
+                end
+            end)
+            self.events[eventId] = event
+        end
+        return self.events[eventId]
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Frame.prototype,
+    "onMouseEnter",
+    {get = function(self)
+        return self:getEvent(FRAMEEVENT_MOUSE_ENTER)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Frame.prototype,
+    "onMouseLeave",
+    {get = function(self)
+        return self:getEvent(FRAMEEVENT_MOUSE_LEAVE)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Frame.prototype,
+    "onMouseUp",
+    {get = function(self)
+        return self:getEvent(FRAMEEVENT_MOUSE_UP)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Frame.prototype,
+    "onMouseWheel",
+    {get = function(self)
+        return self:getEvent(
+            FRAMEEVENT_MOUSE_WHEEL,
+            function() return BlzGetTriggerFrameValue() / 120 end
+        )
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Frame.prototype,
+    "popupMenuItemChangeEvent",
+    {get = function(self)
+        local value = self.value
+        return self:getEvent(
+            FRAMEEVENT_POPUPMENU_ITEM_CHANGED,
+            function()
+                local previousValue = value
+                value = BlzGetTriggerFrameValue()
+                return self, previousValue, value
+            end
+        )
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Frame.prototype,
+    "valueChangeLocalEvent",
+    {get = function(self)
+        local event = __TS__New(Event)
+        local lastValue = self.value
+        local function listener()
+            if self.value ~= lastValue then
+                local newValue = self.value
+                Event.invoke(event, self, lastValue, newValue)
+                lastValue = newValue
+            end
+        end
+        Timer.onPeriod[1 / 64]:addListener(listener)
+        self.destroyEvent:addListener(function()
+            Timer.onPeriod[1 / 64]:removeListener(listener)
+        end)
+        rawset(self, "valueChangeLocalEvent", event)
+        return event
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Frame.prototype,
+    "onSliderValueChanged",
+    {get = function(self)
+        return self:getEvent(
+            FRAMEEVENT_SLIDER_VALUE_CHANGED,
+            function() return BlzGetTriggerFrameValue() end
+        )
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Frame.prototype,
+    "onEditBoxTextChange",
+    {get = function(self)
+        return self:getEvent(
+            FRAMEEVENT_EDITBOX_TEXT_CHANGED,
+            function() return BlzGetTriggerFrameText() end
+        )
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Frame.prototype,
+    "onEditBoxTextChangeLocal",
+    {get = function(self)
+        local event = __TS__New(Event)
+        local lastValue = self.text
+        local function listener()
+            if self.text ~= lastValue then
+                local newValue = self.text
+                Event.invoke(event, self, lastValue, newValue)
+                lastValue = newValue
+            end
+        end
+        Timer.onPeriod[1 / 64]:addListener(listener)
+        self.destroyEvent:addListener(function()
+            Timer.onPeriod[1 / 64]:removeListener(listener)
+        end)
+        rawset(self, "onEditBoxTextChangeLocal", event)
+        return event
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Frame.prototype,
+    "onEnable",
+    {get = function(self)
+        local event = __TS__New(Event)
+        rawset(self, "onEnable", event)
+        return event
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Frame.prototype,
+    "onDisable",
+    {get = function(self)
+        local event = __TS__New(Event)
+        rawset(self, "onDisable", event)
+        return event
+    end},
+    true
+)
+__TS__ObjectDefineProperty(
+    Frame,
+    "onKeyPress",
+    {get = function(self)
+        if not self.onKeyPressEvent then
+            self.onKeyPressEvent = __TS__New(
+                TriggerEvent,
+                function(trigger) return Timer:simple(
+                    0,
+                    function()
+                        do
+                            local oskey = 10
+                            while oskey < 255 do
+                                do
+                                    local metakey = 0
+                                    while metakey < 5 do
+                                        for ____, player in ipairs(Player.all) do
+                                            BlzTriggerRegisterPlayerKeyEvent(
+                                                trigger,
+                                                player.handle,
+                                                ConvertOsKeyType(oskey),
+                                                metakey,
+                                                true
+                                            )
+                                        end
+                                        metakey = metakey + 1
+                                    end
+                                end
+                                oskey = oskey + 1
+                            end
+                        end
+                    end
+                ) end,
+                function() return Player:of(GetTriggerPlayer()), BlzGetTriggerPlayerKey(), BlzGetTriggerPlayerMetaKey() end
+            )
+        end
+        return self.onKeyPressEvent
+    end}
+)
+__TS__ObjectDefineProperty(
+    Frame,
+    "onKeyRelease",
+    {get = function(self)
+        if not self.onKeyReleaseEvent then
+            self.onKeyReleaseEvent = __TS__New(
+                TriggerEvent,
+                function(trigger) return Timer:simple(
+                    0,
+                    function()
+                        do
+                            local oskey = 10
+                            while oskey < 255 do
+                                do
+                                    local metakey = 0
+                                    while metakey < 5 do
+                                        for ____, player in ipairs(Player.all) do
+                                            BlzTriggerRegisterPlayerKeyEvent(
+                                                trigger,
+                                                player.handle,
+                                                ConvertOsKeyType(oskey),
+                                                metakey,
+                                                false
+                                            )
+                                        end
+                                        metakey = metakey + 1
+                                    end
+                                end
+                                oskey = oskey + 1
+                            end
+                        end
+                    end
+                ) end,
+                function() return Player:of(GetTriggerPlayer()), BlzGetTriggerPlayerKey(), BlzGetTriggerPlayerMetaKey() end
+            )
+        end
+        return self.onKeyReleaseEvent
+    end}
+)
+__TS__ObjectDefineProperty(
+    Frame,
+    "onMouseUp",
+    {get = function(self)
+        local event = __TS__New(
+            TriggerEvent,
+            function(trigger) return Timer:simple(
+                0,
+                function()
+                    for ____, player in ipairs(Player.all) do
+                        TriggerRegisterPlayerEvent(trigger, player.handle, EVENT_PLAYER_MOUSE_UP)
+                    end
+                end
+            ) end,
+            function() return Player:of(GetTriggerPlayer()), BlzGetTriggerPlayerMouseButton(), BlzGetTriggerPlayerMouseX(), BlzGetTriggerPlayerMouseY() end
+        )
+        rawset(____exports.Frame, "onMouseUp", event)
+        return event
+    end}
+)
+__TS__ObjectDefineProperty(
+    Frame,
+    "onMouseDown",
+    {get = function(self)
+        if not self.onMouseDownEvent then
+            self.onMouseDownEvent = __TS__New(
+                TriggerEvent,
+                function(trigger) return Timer:simple(
+                    0,
+                    function()
+                        for ____, player in ipairs(Player.all) do
+                            TriggerRegisterPlayerEvent(trigger, player.handle, EVENT_PLAYER_MOUSE_DOWN)
+                        end
+                    end
+                ) end,
+                function() return Player:of(GetTriggerPlayer()), BlzGetTriggerPlayerMouseButton(), BlzGetTriggerPlayerMouseX(), BlzGetTriggerPlayerMouseY() end
+            )
+        end
+        return self.onMouseDownEvent
+    end}
+)
+__TS__ObjectDefineProperty(
+    Frame,
+    "onMouseMove",
+    {get = function(self)
+        local event = __TS__New(
+            TriggerEvent,
+            function(trigger) return Timer:simple(
+                0,
+                function()
+                    for ____, player in ipairs(Player.all) do
+                        TriggerRegisterPlayerEvent(trigger, player.handle, EVENT_PLAYER_MOUSE_MOVE)
+                    end
+                end
+            ) end,
+            function() return Player:of(GetTriggerPlayer()), BlzGetTriggerPlayerMouseX(), BlzGetTriggerPlayerMouseY() end
+        )
+        rawset(____exports.Frame, "onMouseMove", event)
+        return event
+    end}
+)
+__TS__ObjectDefineProperty(
+    Frame,
+    "onMouseMoveLocal",
+    {get = function(self)
+        local invoke = Event.invoke
+        local event = __TS__New(Event)
+        local syncX = 0
+        local syncY = 0
+        local syncCamX = getCameraTargetPositionX()
+        local syncCamY = getCameraTargetPositionY()
+        local lastX = syncX
+        local lastY = syncY
+        self.onMouseMove:addListener(function(player, x, y)
+            if player.isLocal then
+                syncX = x
+                syncY = y
+                syncCamX = getCameraTargetPositionX()
+                syncCamY = getCameraTargetPositionY()
+                lastX = x
+                lastY = y
+                invoke(event, x, y)
+            end
+        end)
+        Timer.onPeriod[1 / 64]:addListener(function()
+            if syncX == 0 and syncY == 0 then
+                return
+            end
+            local x = syncX + (getCameraTargetPositionX() - syncCamX)
+            local y = syncY + (getCameraTargetPositionY() - syncCamY)
+            if x ~= lastX or y ~= lastY then
+                lastX = x
+                lastY = y
+                invoke(event, x, y)
+            end
+        end)
+        rawset(____exports.Frame, "onMouseMoveLocal", event)
+        return event
+    end}
+)
+leftBorderFrame = ____exports.Frame:of(leftBorder)
+rightBorderFrame = ____exports.Frame:of(rightBorder)
+return ____exports