SlideWindows.ahk

;TODO:
;-When a 7plus dialog is shown while a slide window was activated(not through border), it mostly happens that the window doesn't slide out.
;If it does, it sometimes gets activated improperly after confirming the dialog. The window is not lost anymore however. Activating it again in taskbar makes it slide in.
;TODO on Return:
;FileOpen Dialog messes up on XP when sliding out
;Issue with window position on Clearlooks skin (offset of 3, i.e. y = 3 is recognized as 0)
;

;Slide Directions:
Class SlideDirections
{
    static INVALID := 0
    static LEFT := 1
    static TOP := 2
    static RIGHT := 3
    static BOTTOM := 4
}
;Slide States:
Class SlideStates
{
    static NO_SLIDEWINDOW := -1
    static HIDDEN := 0
    static VISIBLE := 1
    static SLIDING_IN := 2
    static SLIDING_OUT := 3
    static RELEASING := 4
}
Class CSlideWindow
{
    __New(hwnd, Direction)
    {
        global SlideWindows
        if(!SlideWindows.CanAddSlideWindow(hwnd, Direction))
            return 0
        this.hwnd := hwnd
        this.SlideState := SlideStates.NO_SLIDEWINDOW
        this.Direction := Direction
        ; this.ParentWindows := GetParentWindows(hwnd) ;Parent windows might be used later to dynamically consider this window at screen borders
        this.GetChildWindows(0) ;Child windows are fetched when sliding takes place so they're more recent, but the always on top state is stored here the first time
        WinGet, ExStyle, ExStyle, % "ahk_id " this.hwnd
        this.WasOnTop := ExStyle & 0x8
        this.OriginalPosition := WinGetPos("ahk_id " this.hwnd)
        Loop % this.ChildWindows.MaxIndex()
            this.ChildWindows.OriginalPosition := WinGetPos("ahk_id " this.ChildWindows.hwnd)
        this.SlideOut()
    }
    __Delete()
    {
        if(this.SlideState = SlideStates.HIDDEN) ;only release windows that were not already released
            this.Release()
    }
    ;This function slides a window into the screen, making it visible
    SlideIn()
    {
        Debug("Slide in")
        DetectHiddenWindows, On
        ;Disable Minimize/Restore animation
        ;RegRead, Animate, HKCU, Control Panel\Desktop\WindowMetrics , MinAnimate
        ;VarSetCapacity(struct, 8, 0)
        ;NumPut(8, struct, 0, "UInt")
        ;NumPut(0, struct, 4, "Int")
        ;DllCall("SystemParametersInfo", "UINT", 0x0049,"UINT", 8,"STR", struct,"UINT", 0x0003) ;SPI_SETANIMATION            0x0049 SPIF_SENDWININICHANGE 0x0002
        this.GetChildWindows(0)
        SetWinDelay, 0
        this.SlideState := SlideStates.SLIDING_IN
        Loop % this.ChildWindows.MaxIndex() + 1 ;Set all windows to always on top
        {
            hwnd := A_Index = 1 ? this.hwnd : this.ChildWindows[A_Index - 1].hwnd
            WinSet, AlwaysOnTop, On , ahk_id %hwnd%
            if(Settings.Windows.SlideWindows.HideSlideWindows)
                if(A_Index = 1 || this.ChildWindows[A_Index - 1].WasVisible)
                    WinShow ahk_id %hwnd%
        }
        WinActivate % "ahk_id " this.Active

        GetVirtualScreenCoordinates(VirtualLeft, VirtualTop, VirtualRight, VirtualBottom) ;We want the coordinates of the upper left and lower right point
        VirtualRight += VirtualLeft
        VirtualBottom += VirtualTop

        ;Calculate target position
        this.Position := WinGetPos("ahk_id " this.hwnd)
        Loop % this.ChildWindows.MaxIndex()
            this.ChildWindows[A_Index].Position := WinGetPos("ahk_id " this.ChildWindows[A_Index].hwnd)
        if(this.Direction = SlideDirections.LEFT)
        {
            this.ToX := VirtualLeft
            this.ToY := this.Position.y
            Loop % this.ChildWindows.MaxIndex()
            {
                this.ChildWindows[A_Index].ToX := max(this.ToX + this.ChildWindows[A_Index].Position.x - this.Position.x, VirtualLeft)
                this.ChildWindows[A_Index].ToY := this.ChildWindows[A_Index].Position.y
            }
        }
        else if(this.Direction = SlideDirections.TOP)
        {
            this.ToX := this.Position.x
            this.ToY := VirtualTop
            Loop % this.ChildWindows.MaxIndex()
            {
                this.ChildWindows[A_Index].ToX := this.ChildWindows[A_Index].Position.x
                this.ChildWindows[A_Index].ToY := max(this.ToY + this.ChildWindows[A_Index].Position.y - this.Position.y, VirtualTop)
            }
        }
        else if(this.Direction = SlideDirections.RIGHT)
        {
            this.ToX := VirtualRight - this.Position.w
            this.ToY := this.Position.y
            Loop % this.ChildWindows.MaxIndex()
            {
                this.ChildWindows[A_Index].ToX := min(this.ToX + this.ChildWindows[A_Index].Position.x - this.Position.x, VirtualRight - this.ChildWindows[A_Index].Position.w)
                this.ChildWindows[A_Index].ToY := this.ChildWindows[A_Index].Position.y
            }
        }
        else if(this.Direction = SlideDirections.BOTTOM)
        {
            this.ToX := this.Position.x
            this.ToY := VirtualBottom - this.Position.h
            Loop % this.ChildWindows.MaxIndex()
            {
                this.ChildWindows[A_Index].ToX := this.ChildWindows[A_Index].Position.x
                this.ChildWindows[A_Index].ToY := min(this.ToY + this.ChildWindows[A_Index].Position.y - this.Position.y, VirtualBottom - this.ChildWindows[A_Index].Position.h)
            }
        }
        this.Move()
        this.SlideState := SlideStates.VISIBLE
        ;Possibly activate Minimize animation again
        ;if(Animate = 1)
        ;{
        ;    NumPut(1, struct, 4, "UInt")
        ;    DllCall("SystemParametersInfo", "UINT", 0x0049,"UINT", 8,"STR", struct,"UINT", 0x0003) ;SPI_SETANIMATION            0x0049 SPIF_SENDWININICHANGE 0x0002
        ;}
    }
    ;This function slides a window outside the screen, hiding it
    SlideOut()
    {
        global PreviousWindow, SlideWindows
        Debug("Slide out")
        DetectHiddenWindows, On
        ;Disable Minimize/Restore animation
        ;RegRead, Animate, HKCU, Control Panel\Desktop\WindowMetrics , MinAnimate
        ;VarSetCapacity(struct, 8, 0)
        ;NumPut(8, struct, 0, "UInt")
        ;NumPut(0, struct, 4, "Int")
        ;DllCall("SystemParametersInfo", "UINT", 0x0049,"UINT", 8,"STR", struct,"UINT", 0x0003) ;SPI_SETANIMATION            0x0049 SPIF_SENDWININICHANGE 0x0002
        SetWinDelay 0
        this.SlideState := SlideStates.SLIDING_OUT
        this.GetChildWindows(1) ;Update the current visibility state of child windows
        Active := WinExist("A") + 0 ;Store the active slide/child window so it can be activated on next slide in
        if(this.hwnd = Active)
            this.Active := Active
        else if(this.ChildWindows.FindKeyWithValue("hwnd", Active))
            this.Active := Active
        else
            PreviousWindow := Active
        GetVirtualScreenCoordinates(VirtualLeft, VirtualTop, VirtualRight, VirtualBottom) ;We want the coordinates of the upper left and lower right point
        VirtualRight += VirtualLeft
        VirtualBottom += VirtualTop
        OffsetFromScreen := 10
        ;Calculate target position
        this.Position := WinGetPos("ahk_id " this.hwnd)
        Loop % this.ChildWindows.MaxIndex()
            this.ChildWindows[A_Index].Position := WinGetPos("ahk_id " this.ChildWindows[A_Index].hwnd)
        if(this.Direction = SlideDirections.LEFT)
        {
            this.ToX := VirtualLeft - this.Position.w - OffsetFromScreen
            this.ToY := this.Position.y
            Loop % this.ChildWindows.MaxIndex() ;Correct for offset of child windows
                this.ToX := min(this.ToX, this.ToX - ((this.ChildWindows[A_Index].Position.x + this.ChildWindows[A_Index].Position.w) - (this.Position.x + this.Position.w)))
            Loop % this.ChildWindows.MaxIndex()
            {
                this.ChildWindows[A_Index].ToX := min(this.ToX + this.ChildWindows[A_Index].Position.x - this.Position.x, VirtualLeft - this.ChildWindows[A_Index].Position.w)
                this.ChildWindows[A_Index].ToY := this.ChildWindows[A_Index].Position.y
            }
            this.SlideOutPos := this.Position.y
            this.SlideOutLen := this.Position.h
        }
        else if(this.Direction = SlideDirections.TOP)
        {
            this.ToX := this.Position.x
            this.ToY := VirtualTop - this.Position.h - OffsetFromScreen
            Loop % this.ChildWindows.MaxIndex() ;Correct for offset of child windows
                this.ToY := min(this.ToY, this.ToY - ((this.ChildWindows[A_Index].Position.y + this.ChildWindows[A_Index].Position.h) - (this.Position.y + this.Position.h)))
            Loop % this.ChildWindows.MaxIndex()
            {
                this.ChildWindows[A_Index].ToX := this.ChildWindows[A_Index].Position.x
                this.ChildWindows[A_Index].ToY := min(this.ToY + this.ChildWindows[A_Index].Position.y - this.Position.y, VirtualTop - this.ChildWindows[A_Index].Position.h)
            }
            this.SlideOutPos := this.Position.x
            this.SlideOutLen := this.Position.w
        }
        else if(this.Direction = SlideDirections.RIGHT)
        {
            this.ToX := VirtualRight + OffsetFromScreen
            this.ToY := this.Position.y
            Loop % this.ChildWindows.MaxIndex() ;Correct for offset of child windows
                this.ToX := max(this.ToX, this.ToX + (this.Position.x - this.ChildWindows[A_Index].Position.x))
            Loop % this.ChildWindows.MaxIndex()
            {
                this.ChildWindows[A_Index].ToX := max(this.ToX + this.ChildWindows[A_Index].Position.x - this.Position.x, VirtualRight)
                this.ChildWindows[A_Index].ToY := this.ChildWindows[A_Index].Position.y
            }
            this.SlideOutPos := this.Position.y
            this.SlideOutLen := this.Position.h
        }
        else if(this.Direction = SlideDirections.BOTTOM)
        {
            this.ToX := this.Position.x
            this.ToY := VirtualBottom + OffsetFromScreen
            Loop % this.ChildWindows.MaxIndex() ;Correct for offset of child windows
                this.ToY := max(this.ToY, this.ToY + (this.Position.y - this.ChildWindows[A_Index].Position.y))
            Loop % this.ChildWindows.MaxIndex()
            {
                this.ChildWindows[A_Index].ToX := this.ChildWindows[A_Index].Position.x
                this.ChildWindows[A_Index].ToY := max(this.ToY + this.ChildWindows[A_Index].Position.y - this.Position.y, VirtualBottom)
            }
            this.SlideOutPos := this.Position.x
            this.SlideOutLen := this.Position.w
        }
        this.Move()

        WinGet, win, List
        found := false
        Loop, %win%
            if (win%A_Index% = this.hwnd)
                found := true
            else if(found && !SlideWindows.GetByWindowHandle(win%A_Index%))
            {
                found := win%A_Index%
                break
            }
        WinActivate, % "ahk_id " found
        if(!Length := this.ChildWindows.MaxIndex())
            Length := 0
        ;hide/minimize all child windows and main wind
        if(Settings.Windows.SlideWindows.HideSlideWindows)
            Loop % Length + 1
            {
                hwnd := A_Index = 1 ? this.hwnd : this.ChildWindows[A_Index - 1].hwnd
                WinHide, ahk_id %hwnd%
            }
        ;~ WaitForEvent("SlideWindowResize", 1000)
        ;Debug("post minimize")
        this.SlideState := SlideStates.HIDDEN
        Debug("slidestate set to HIDDEN")
        ;Possibly activate Minimize animation again
        ;if(Animate = 1)
        ;{
        ;    NumPut(1, struct, 4, "UInt")
        ;    DllCall("SystemParametersInfo", "UINT", 0x0049,"UINT", 8,"STR", struct,"UINT", 0x0003) ;SPI_SETANIMATION            0x0049 SPIF_SENDWININICHANGE 0x0002
        ;}
    }
    ;This function moves all involved windows to the stored coordinates
    Move()
    {
        Moved := true
        while(Moved) ;While target position is not reached, move all child windows and the main window
        {
            Moved := false
            diffX := this.toX - this.Position.x
            diffY := this.toY - this.Position.y
            StepX := Round(absmin(dirmax(diffX * 2 / 10, 10), diffX))
            StepY := Round(absmin(dirmax(diffY * 2 / 10, 10), diffY))
            if(StepX != 0 || StepY != 0) ;Move the main window
            {
                this.Position.x += StepX
                this.Position.y += StepY
                WinMove, % "ahk_id " this.hwnd, , % this.Position.x, % this.Position.y
                Moved := true
            }
            Loop % this.ChildWindows.MaxIndex() ;Move all child windows
            {
                hwnd := this.ChildWindows[A_Index].hwnd
                diffX := this.ChildWindows[A_Index].toX - this.ChildWindows[A_Index].Position.x
                diffY := this.ChildWindows[A_Index].toY - this.ChildWindows[A_Index].Position.y
                StepX := Round(absmin(dirmax(diffX * 2 / 10, 10), diffX))
                StepY := Round(absmin(dirmax(diffY * 2 / 10, 10), diffY))

                WinGet, minstate , minmax, ahk_id %hwnd% ;Don't move child windows which might be hidden/minimized
                if(minstate = -1)
                    continue
                if(StepX = 0 && StepY = 0)
                    continue
                this.ChildWindows[A_Index].Position.x += StepX
                this.ChildWindows[A_Index].Position.y += StepY
                WinMove, ahk_id %hwnd%, , % this.ChildWindows[A_Index].Position.x, % this.ChildWindows[A_Index].Position.y
                Moved := true
            }
            Sleep 10
        }
        this.Remove("Position")
        this.Remove("ToX")
        this.Remove("ToY")
        Loop % this.ChildWindows.MaxIndex()
        {
            this.ChildWindows[A_Index].Remove("Position")
            this.ChildWindows[A_Index].Remove("ToX")
            this.ChildWindows[A_Index].Remove("ToY")
        }
    }
    ;This functions removes the "Slide window" property from a window, sliding it in and showing it
    ;If Soft is true, the window will not be moved. This is used for releasing because of window moving and resizing
    Release(Soft = 0)
    {
        global SlideWindows
        if(!this.hwnd) ;Make sure the slide window was actually successfully created
            return
        Debug("Release Slide Window")
        DetectHiddenWindows, On

        ;Make sure that no window is accidently released outside of the screen.
        GetVirtualScreenCoordinates(VirtualLeft, VirtualTop, VirtualWidth, VirtualHeight)
        if(Soft && IsObject(WindowList[hwnd]) && RectsSeparate(VirtualLeft, VirtualTop, VirtualWidth, VirtualHeight, WindowList[hwnd].x, WindowList[hwnd].y, WindowList[hwnd].w, WindowList[hwnd].h))
            Soft := 0

        this.SlideState := SlideStates.RELEASING
        if(!Soft)
        {
            WinShow, % "ahk_id " this.hwnd
            this.Position := WinGetPos("ahk_id " this.hwnd)
            this.ToX := this.OriginalPosition.x
            this.ToY := this.OriginalPosition.y
            Loop % this.ChildWindows.MaxIndex()
            {
                this.ChildWindows[A_Index].Position := WinGetPos("ahk_id " this.ChildWindows[A_Index].hwnd)
                this.ChildWindows[A_Index].ToX := this.ChildWindows[A_Index].OriginalPosition.x
                this.ChildWindows[A_Index].ToY := this.ChildWindows[A_Index].OriginalPosition.y
                if(this.ChildWindows[A_Index].WasVisible)
                    WinShow, % "ahk_id " this.ChildWindows[A_Index].hwnd
            }
            WinActivate, % "ahk_id " this.Active
            this.Move()
        }
        WinSet, AlwaysOnTop, % this.WasOnTop ? "On" : "Off", % "ahk_id " this.hwnd
        Loop % this.ChildWindows.MaxIndex()
            WinSet, AlwaysOnTop, % this.ChildWindows.WasOnTop ? "On" : "Off", % "ahk_id " this.ChildWindows[A_Index].hwnd
        if(index := SlideWindows.FindKeyWithValue("hwnd", this.hwnd)) ;Remove if not already done so
            SlideWindows.Remove(index)
    }
    ;Calculates a bounding box around the slide window and its child windows
    CalculateBoundingBox(ByRef bLeft, ByRef bTop, ByRef bRight, ByRef bBottom)
    {
        WinGetPos, x, y, w, h, % "ahk_id " this.hwnd
        bLeft := x
        bRight := x + w
        bTop := y
        bBottom := y + h
        Loop % this.ChildWindows.MaxIndex() ;Create a bounding box of all involved windows
        {
            WinGet, Style, Style, % "ahk_id " this.ChildWindows[A_Index].hwnd
            if(!(Style & 0x10000000))
                continue
            WinGetPos l, t, r, b, % "ahk_id " this.ChildWindows[A_Index].hwnd
            r += l
            b += t
            if(l < bLeft)
                bLeft := l
            if(r > bRight)
                bRight := r
            if(t < bTop)
                bTop := t
            if(b > bBottom)
                bBottom := b
        }
    }
    ;Get child windows
    GetChildWindows(UpdateVisibility)
    {
        DetectHiddenWindows, On
        WinGet, Windows, List
        if(!IsObject(this.ChildWindows))
            this.ChildWindows := Array()
        FoundChildWindows := Array()
        Loop % Windows ;Iterate over all windows, find out which ones are child windows of hwnd and add them to the list
        {
            hParent := Windows%A_Index%
            if(hParent = this.hwnd) ;Skip the window itself
                continue
            while(hParent && hParent != this.hwnd)
                hParent := DllCall("GetParent", "PTR", hParent)
            if(hParent = this.hwnd)
            {
                class := WinGetClass("ahk_id " Windows%A_Index%)
                classParent := WinGetClass("ahk_id " hParent) ;Some stuff here is only added for debugging, may be removed later if all really works fine.
                if(InStr("tooltips_class32,WorkerW,IME,MSCTFIME UI", class)) ;Ignore some common helper windows
                    continue
                FoundChildWindows.Insert(Windows%A_Index%)
                WinGet, Style, Style, % "ahk_id " Windows%A_Index% ;Store if the child window is visible
                if(index := this.ChildWindows.FindKeyWithValue("hwnd", Windows%A_Index%)) ;By refreshing the ChildWindows array instead of replacing it, we make sure to keep the original visible and always on top states of child windows
                {
                    if(UpdateVisibility)
                        this.ChildWindows[index].WasVisible := Style & 0x10000000 ? 1 : 0
                    continue
                }
                WinGet, ExStyle, ExStyle, % "ahk_id " Windows%A_Index% ;Also store always on top state of new child windows
                if(this.SlideState = SlideStates.VISIBLE) ;Make sure that newly created windows will be set to always on top when the window is already slided out
                    WinSet, AlwaysOnTop, On, % "ahk_id " Windows%A_Index%
                this.ChildWindows.Insert(Object("hwnd", Windows%A_Index%, "WasOnTop", ExStyle & 0x8, "WasVisible", Style & 0x10000000, "Class", class, "ClassParent", ClassParent))
            }
        }
        index := 1
        Loop % this.ChildWindows.MaxIndex() ;Delete loop for child windows which were closed
        {
            if(FoundChildWindows.IndexOf(this.ChildWindows[index].hwnd))
                index++
            else
                this.ChildWindows.Remove(index)
        }
    }
}
Class CSlideWindows
{
    __New()
    {
        this.base.base := Array()
        ;Read list of window classes that were closed outside of the screen
        if(FileExist(Settings.ConfigPath "\ClosedWindowsOutsideScreen.xml"))
        {
            FileRead, xml, % Settings.ConfigPath "\ClosedWindowsOutsideScreen.xml"
            XMLObject := XML_Read(xml)
            this.ClosedWindowsOutsideScreen := IsObject(XMLObject) && IsObject(XMLObject.Window) && XMLObject.Window.MaxIndex() > 0 ? XMLObject.Window : Array(XMLObject.Window)
        }
        else
            this.ClosedWindowsOutsideScreen := Array()
    }
    OnExit()
    {
        if(this.ClosedWindowsOutsideScreen.MaxIndex() > 0)
            XML_Save(Object("Window", this.ClosedWindowsOutsideScreen), Settings.ConfigPath "\ClosedWindowsOutsideScreen.xml")
        else
            FileDelete, % Settings.ConfigPath "\ClosedWindowsOutsideScreen.xml"
        this.ReleaseAll()
    }

    ;Called when the property is changed so existing slide windows can be updated.
    On_HideSlideWindows_Changed()
    {
        return ;TODO: This doesn't work unfortunately.
        for index, SlideWindow in this
        {
            if(SlideWindow.SlideState = SlideStates.HIDDEN)
            {
                if(Settings.Windows.SlideWindows.HideSlideWindows)
                    WinHide, % "ahk_id " SlideWindow.hwnd
                else
                    PostMessage, 0x112, 0xF020, , , % "ahk_id " SlideWindow.hwnd
            }
        }
    }

    ;Called when the property is changed so existing slide windows can be updated.
    On_LimitToOnePerSide_Changed()
    {
        dir := []
        pos := 1
        if(Settings.Windows.SlideWindows.LimitToOnePerSide)
            Loop % this.MaxIndex()
            {
                SlideWindow := this[pos]
                if(dir[SlideWindow.dir])
                    SlideWindow.Release()
                else
                {
                    dir[SlideWindow.dir] := 1
                    pos++
                }
            }
    }
    CanAddSlideWindow(hwnd, Direction)
    {
        Class := WinGetClass("ahk_id " hwnd)
        if(!Class || InStr("WorkerW,Progman,Shell_TrayWnd,BaseBar,DV2ControlHost,Static", Class))
            return false
        if(IsFullScreen("A", true, true))
            return false
        if(Direction = GetTaskbarDirection())
            return false
        ;Ignore maximized windows
        WinGet, maxstate , minmax, ahk_id %hwnd%
        if(maxstate = 1)
            return
        ;Accessor doesn't support sliding yet
        if(hwnd = CAccessor.Instance.GUI.hwnd)
            return false
        return this.IsSlideSpaceFree(hwnd, Direction)
    }
    IsSlideSpaceOccupied(px, py, width, height, dir)
    {
        if(dir = 1 || dir = 3)
        {
            Loop % this.MaxIndex() ;Check all slide windows
            {
                SlideWindow := this[A_INDEX]
                if(SlideWindow.Direction = dir)
                {
                    BorderY := (Height - 2 * Settings.Windows.SlideWindows.BorderSize > 0) ? Settings.Windows.SlideWindows.BorderSize : 0
                    objBorderY := (SlideWindow.SlideOutLen - 2 * Settings.Windows.SlideWindows.BorderSize > 0) ? Settings.Windows.SlideWindows.BorderSize : 0
                    Y1 := pY + borderY
                    Y2 := pY + Height - borderY
                    objY1 := SlideWindow.SlideOutPos + objBorderY
                    objY2 := SlideWindow.SlideOutPos + SlideWindow.SlideOutLen - objBorderY
                    if Y1 between %objY1% and %objY2%
                        return SlideWindow
                    if Y2 between %objY1% and %objY2%
                        return SlideWindow
                    if objY1 between %Y1% and %Y2%
                        return SlideWindow
                    if objY2 between %Y1% and %Y2%
                        return SlideWindow
                }
            }
        }
        else if(dir = 2 || dir = 4)
        {
            Loop % this.MaxIndex() ;Check all slide windows
            {
                SlideWindow := this[A_INDEX]
                if(SlideWindow.Direction = dir)
                {
                    borderX := (Width - 2 * Settings.Windows.SlideWindows.BorderSize > 0) ? Settings.Windows.SlideWindows.BorderSize : 0
                    objBorderX := (SlideWindow.SlideOutLen - 2 * Settings.Windows.SlideWindows.BorderSize > 0) ? Settings.Windows.SlideWindows.BorderSize : 0
                    X1 := pX + borderX
                    X2 := pX + Width - borderX
                    objX1 := SlideWindow.SlideOutPos + objBorderX
                    objX2 := SlideWindow.SlideOutPos + SlideWindow.SlideOutLen - objBorderX
                    if X1 between %objX1% and %objX2%
                        return SlideWindow
                    if X2 between %objX1% and %objX2%
                        return SlideWindow
                    if objX1 between %X1% and %X2%
                        return SlideWindow
                    if objX2 between %X1% and %X2%
                        return SlideWindow
                }
            }
        }
        return 0
    }
    IsSlideSpaceFree(hwnd, dir)
    {
        if(Settings.Windows.SlideWindows.LimitToOnePerSide)
            return this.FindKeyWithValue("Direction", dir) = 0
        WinGetPos X, Y, Width, Height, ahk_id %hwnd%
        return !this.IsSlideSpaceOccupied(X, Y, Width, Height, dir)
    }
    ReleaseAll()
    {
        Loop % this.MaxIndex()
            this[1].Release(0)
    }
    ;This is called when a window gets resized to see if it needs to be released
    CheckResizeReleaseCondition(hwnd)
    {
        GetVirtualScreenCoordinates(VirtualLeft, VirtualTop, VirtualWidth, VirtualHeight)
        SlideWindow := this.GetItemWithValue("hwnd", hwnd)
        if(!SlideWindow)
            return
        if(SlideWindow.SlideState = SlideStates.VISIBLE)
        {
            WinGetPos, , , w, h, % "ahk_id " slidewindow.hwnd
            Debug("release due to resize, state: " SlideWindow.SlideState ", w: " w ", h: " h)
            SlideWindow.Release(SlideWindow.SlideState = SlideStates.VISIBLE)
        }
        RaiseEvent("SlideWindowResize")
    }
    ;This is called when a window gets closed to see if a slide window needs to be released
    WindowClosed(hwnd)
    {
        global WindowList
        index := 1
        DetectHiddenWindows, On
        Loop % this.MaxIndex()
        {
            SlideWindow := this[index]
            if(!WinExist("ahk_id " SlideWindow.hwnd))
            {
                Debug("release due to close")
                SlideWindow.Release()
            }
            else
                index++
        }
        ;Check if a window was closed outside of the screen and add it to a list so it can be moved inside again when it gets opened again
        if(IsObject(WindowList[hwnd]) && !IsWindowOnScreen(WindowList[hwnd]))
        {
            class := WindowList[hwnd].class
            if(!this.ClosedWindowsOutsideScreen.IndexOf(class))
                this.ClosedWindowsOutsideScreen.Insert(class)
        }
    }
    ;This is called when a window gets activated and takes care of sliding windows out/in that were (de)activated
    WindowActivated()
    {
        if(IsContextMenuActive()) ;Ignore context menus
            return
        Debug("Window activated")
        hwnd := WinExist("A") + 0
        this.ActivatedWindow := hwnd
        SetTimer, CheckForNewChildWindows, -100
        SlideWindow := this.GetByWindowHandle(hwnd, ChildIndex)
        if(IsObject(SlideWindow) && SlideWindow.SlideState = SlideStates.VISIBLE)
            SlideWindow.Active := WinExist("A") + 0 ;Last active slide window
        index := this.FindKeyWithValueBetween("SlideState", SlideStates.VISIBLE, SlideStates.RELEASING)
        CurrentSlideWindow := this[index]
        class := WinGetClass("ahk_id " hwnd)
        ;If a window outside of the screen was activated and it's stored in the list of windows that were closed while being outside of the screen, move it in
        if(!SlideWindow && index := this.ClosedWindowsOutsideScreen.indexOf(class) && !IsWindowOnScreen(hwnd))
        {
            WinMove, ahk_id %hwnd%, , % A_ScreenWidth / 2 - w / 2, % A_ScreenHeight / 2 - h / 2
            this.ClosedWindowsOutsideScreen.Remove(index)
        }
        if(CurrentSlideWindow && CurrentSlideWindow = SlideWindow) ;A window from the same slide window group was activated
            return
        if(CurrentSlideWindow)
        {
            WinGet, minstate , minmax, % "ahk_id " CurrentSlideWindow.hwnd
            if(minstate = -1 && CurrentSlideWindow.SlideState = SlideStates.VISIBLE) ;Release slide window that was minimized (but is not currently sliding)
            {
                Debug("release due to minimize, state: " CurrentSlideWindow.SlideState)
                CurrentSlideWindow.Release(1)
            }
            else if(!CurrentSlideWindow.AutoSlideOut)
                CurrentSlideWindow.SlideOut()
        }
        if(SlideWindow && SlideWindow.SlideState = SlideStates.HIDDEN)
        {
            WinGet, minstate , minmax, % "ahk_id " SlideWindow.hwnd
            if(minstate != -1) ;Make sure the window is not minimized anymore
            {
                SlideWindow.AutoSlideOut := false ;Slide windows that were activated directly will only slide out when they're deactivated
                SlideWindow.SlideIn()
            }
        }
    }
    ;Slide windows need to monitor window creation to update child window list when appropriate, but this does not seem to work.
    ;Instead window activation is monitored with a slight delay that allows the window to set its parent state. Function is only left here for reference.
    WindowCreated(hwnd)
    {
    }
    ;Finds a slide window object by one of its windows
    GetByWindowHandle(hwnd, ByRef ChildIndex)
    {
        Loop % this.MaxIndex()
        {
            if(this[A_Index].hwnd = hwnd)
            {
                ChildIndex := 0
                return this[A_Index]
            }
            else if(ChildIndex := this[A_Index].ChildWindows.FindKeyWithValue("hwnd", hwnd))
                return this[A_Index]
        }
    }
    ;This is called when the mouse is moved and takes care of screen border slide window activation and deactivation when the mouse leaves the window
    OnMouseMove(x, y)
    {
        GetVirtualScreenCoordinates(VirtualLeft, VirtualTop, VirtualWidth, VirtualHeight)
        VirtualRight += VirtualLeft
        VirtualBottom += VirtualTop
        if(x = VirtualLeft)
            dir = 1
        else if(y = VirtualTop)
            dir = 2
        else if(x = VirtualLeft + VirtualWidth - 1)
            dir = 3
        else if(y = VirtualTop + VirtualHeight - 1)
            dir = 4
        if((z := GetTaskbarDirection()) = dir || z <= 0)
            return
        if(this.FindKeyWithValueBetween("SlideState", SlideStates.SLIDING_IN, SlideStates.RELEASING)) ;Currently sliding a window, ignore mouse
            return
        ;Check if mouse position matches a slide window border and don't slide in while other slide window is on the screen
        SlideWindow := this.IsSlideSpaceOccupied(x, y, 0, 0, dir)
        if(dir > 0 && SlideWindow && (!Settings.Windows.SlideWindows.BorderActivationRequiresMouseUp || !GetKeyState("LButton", "P") || GetKeyState(Settings.Windows.SlideWindows.ModifierKey, "P")) && !this.FindKeyWithValue("SlideState", SlideStates.VISIBLE))
        {
            this.ActiveWindow := WinExist("A")
            SlideWindow.AutoSlideOut := true
            SlideWindow.SlideIn()
            return
        }
        ;Now see if mouse is currently over a shown slide window and maybe hide it
        MouseGetPos, , , win
        win += 0
        SlideWindow := this.GetItemWithValue("SlideState", SlideStates.VISIBLE)
        if(SlideWindow && SlideWindow.AutoSlideOut && SlideWindow.hwnd != win && !SlideWindow.ChildWindows.FindKeyWithValue("hwnd", win) && !IsContextMenuActive() && !GetKeyState(Settings.Windows.SlideWindows.ModifierKey, "P"))
        {
            SlideWindow.SlideOut()
            WinActivate % "ahk_id " this.ActiveWindow
        }
    }
    CheckForNewChildWindows()
    {
        Parents := GetParentWindows(this.ActivatedWindow)
        Loop % Parents.MaxIndex()
            if(SubItem := this.GetItemWithValue("hwnd", Parents[A_Index]))
            {
                SubItem.GetChildWindows(0)
                break
            }
    }
}
CheckForNewChildWindows:
SlideWindows.CheckForNewChildWindows()
return

;Get parent windows, ignoring some default windows
GetParentWindows(hwnd)
{
    Parents := Array()
    hParent := hwnd
    while(true)
    {
        hParent := DllCall("GetParent", "PTR", hParent)
        Class := WinGetClass("ahk_id " hParent)
        if(InStr("WorkerW,Progman,Shell_TrayWnd,BaseBar,DV2ControlHost,Static", Class)) ;Ignore taskbar and desktop windows
            break
        Parents.Insert(hParent)
    }
    return Parents
}