; Script: TextRender.ahk

#Requires AutoHotkey v2.0-beta.13+

class TextRender {

static call(text:="✿sentinel✿", background_style:="", text_style:="") {

this := super()

this.style1 := background_style

this.style2 := text_style

if (text == "✿sentinel✿")

return this

else

return this.Render(text, background_style, text_style)

}

__Delete() {

this.Forget() ; recipestate ? ← x

this.Free() ; bitmapstate ? ← x

this.Destroy() ; windowstate ? ← x

this.CallEvent("Delete")

TextRender.gdiplusShutdown()

}

__New(OffsetLeft := 0, OffsetTop := 0) {

TextRender.gdiplusStartup()

this.OffsetLeft := OffsetLeft

this.OffsetTop := OffsetTop

this.events := {}

this.OnEvent("LeftMouseDown", this.EventMoveWindow)

this.OnEvent("MiddleMouseDown", this.EventShowCoordinates)

this.OnEvent("RightMouseDown", this.EventCopyData)

this.TimeStamp() ; Sets this.t0 to the current time

this.status := 0xFFFF0001 ; Used to block timers

this.layers := []

this.data := ""

this.style1 := ""

this.style2 := ""

this.hwnd := 0

this.recipestate := 0 ; recipestate ? → 0

this.bitmapstate := 0 ; bitmapstate ? → 0

this.windowstate := 0 ; windowstate ? → 0

return this

}

Remember(data := "", style1 := "", style2 := "") {

this.RememberRecipe(data, style1, style2)

this.recipestate := 1 ; recipestate x → 1

this.CallEvent("Remember")

return this

}

RememberRecipe(data := "", style1 := "", style2 := "") {

if (style1 = "" && style2 = "") {

style1 := this.style1

style2 := this.style2

}

this.data := data

this.style1 := style1

this.style2 := style2

this.layers.push([data, style1, style2])

}

Forget(n := "✿sentinel✿") {

this.ForgetRecipe(n)

this.recipestate := !!this.layers.length

this.CallEvent("Forget") ; recipestate 0 ← x (1 of 2)

return this ; recipestate 0|1 ← x (2 of 2)

}

ForgetRecipe(n := "✿sentinel✿") {

if (n == "✿sentinel✿")

this.layers := []

else

loop min(this.layers.length, n)

this.layers.pop()

}

Destroy() {

if (this.windowstate <= 0)

return this

this.Invalidate()

this.DestroyWindow()

this.windowstate := 0 ; windowstate 0 ← x

this.CallEvent("Destroy")

return this

}

DestroyWindow() {

DllCall("DestroyWindow", "ptr", this.hwnd) ; Sends WM_DESTROY

this.hwnd := 0 ; Don't delete the property, just set it to 0.

}

Create(title := "", style := 0x80000000, styleEx := 0x80088, parent := 0) {

if (this.windowstate >= 1)

return this

this.CreateWindow(title, style, styleEx, parent)

this.windowstate := 1 ; windowstate x → 1

this.CallEvent("Create")

return this

}

CreateWindow(title := "", style := 0x80000000, styleEx := 0x80088, parent := 0) {

WS_POPUP := 0x80000000 ; Allow small windows.

WS_EX_TOPMOST := 0x8 ; Always on top.

WS_EX_TOOLWINDOW := 0x80 ; Hides from Alt+Tab menu. Removes small icon.

WS_EX_LAYERED := 0x80000 ; For UpdateLayeredWindow.

try dpi := DllCall("SetThreadDpiAwarenessContext", "ptr", -3, "ptr")

hwnd := DllCall("CreateWindowEx"

, "uint", styleEx ; dwExStyle

, "str", this.WindowClass() ; lpClassName

, "str", title ; lpWindowName

, "uint", style ; dwStyle

, "int", 0 ; X

, "int", 0 ; Y

, "int", 0 ; nWidth

, "int", 0 ; nHeight

, "ptr", parent ; hWndParent

, "ptr", 0 ; hMenu

, "ptr", 0 ; hInstance

, "ptr", 0 ; lpParam

, "ptr")

try DllCall("SetThreadDpiAwarenessContext", "ptr", dpi, "ptr")

if (hwnd == 0)

throw Error("CreateWindow failed. If #MaxThreads is set to 1, increase it to at least 2.")

DllCall("ShowWindow", "ptr", hwnd, "int", 4) ; SW_SHOWNOACTIVATE

DllCall("SetWindowLong" (A_PtrSize=8 ? "Ptr":""), "ptr", hwnd, "int", 0, "ptr", ObjPtr(this))

this.hwnd := hwnd

if DllCall("GetAncestor", "ptr", hwnd, "uint", 1, "ptr") != DllCall("GetDesktopWindow", "ptr")

this.parent := parent

}

Invalidate() {

if (this.windowstate <= 1)

return this

this.Stop()

this.InvalidateWindow()

this.windowstate := 1 ; windowstate 1 ← x

this.CallEvent("Invalidate")

return this

}

InvalidateWindow() {

this.DeleteProp("WindowTime")

this.DeleteProp("WindowLeft")

this.DeleteProp("WindowTop")

this.DeleteProp("WindowRight")

this.DeleteProp("WindowBottom")

this.DeleteProp("WindowWidth")

this.DeleteProp("WindowHeight")

}

Validate() {

if (this.windowstate >= 2)

return this

this.Create()

this.ValidateWindow()

this.windowstate := 2 ; windowstate x → 2

this.CallEvent("Validate")

return this

}

ValidateWindow() {

WinGetPos &x, &y, &w, &h, this.hwnd

this.HasProp("WindowTime") || this.WindowTime := 0 ; Use a dummy variable here

this.WindowLeft := x

this.WindowTop := y

this.WindowRight := x + w

this.WindowBottom := y + h

this.WindowWidth := w

this.WindowHeight := h

}

Stop() {

if (this.windowstate <= 2)

return this

this.StopWindow()

this.windowstate := 2 ; windowstate 2 ← x

this.CallEvent("Stop")

return this

}

StopWindow() {

this.StopTimer()

}

Start() {

this.Validate()

this.StartWindow()

this.windowstate := 3 ; windowstate x → 3

this.CallEvent("Start")

return this

}

StartWindow() {

this.TimeStamp() ; Sets this.t0 to the current time

this.StartTimer() ; Starts timer using this.WindowTime

}

Resume() {

if (this.windowstate <= 1)

return this

this.ResumeWindow()

this.windowstate := 3 ; windowstate 2 → 3

this.CallEvent("Resume")

return this

}

ResumeWindow() {

this.ResumeTimer()

}

Restart() {

this.Stop()

this.Start()

}

UpdateLayered(alpha := 255) {

if (this.bitmapstate <= 1)

return this

if (this.windowstate <= 0)

this.Create()

this.UpdateLayeredWindow(alpha)

this.Stop()

f := "UpdateLayered"

this.windowstate := 2 ; windowstate x → 2 ← x

this.CallEvent(f) ; bitmapstate 2|3

return this

}

UpdateLayeredWindow(alpha := 255) {

t := this.WindowTime := this.t

x := this.WindowLeft := max(this.BitmapLeft, this.x)

y := this.WindowTop := max(this.BitmapTop, this.y)

x2 := this.WindowRight := min(this.BitmapRight, this.x2)

y2 := this.WindowBottom := min(this.BitmapBottom, this.y2)

w := this.WindowWidth := this.WindowRight - this.WindowLeft

h := this.WindowHeight := this.WindowBottom - this.WindowTop

if !(w && h) { ; If the width and height are zero, render a blank screen.

this.FadeWindow(0) ; windowstate is still 2, even though nothing is on screen.

return

}

pptDst := x - this.OffsetLeft << 32 >>> 32 | y - this.OffsetTop << 32

pptSrc := x - this.BitmapLeft << 32 >>> 32 | y - this.BitmapTop << 32

DllCall("UpdateLayeredWindow"

, "ptr", this.hwnd ; hWnd

, "ptr", 0 ; hdcDst

,"uint64*", pptDst ; *pptDst

,"uint64*", w | h << 32 ; *psize

, "ptr", this.hdc ; hdcSrc

,"uint64*", pptSrc ; *pptSrc

, "uint", 0 ; crKey

, "uint*", alpha << 16 | 0x01 << 24 ; *pblend

, "uint", 2 ; dwFlags

, "int") ; Success = 1

if WinGetExStyle(this.hwnd) & 0x8 ; WS_EX_TOPMOST

WinSetAlwaysOnTop True, this.hwnd ; Set always on top again.

}

FadeWindow(alpha) {

DllCall("UpdateLayeredWindow"

, "ptr", this.hwnd ; hWnd

, "ptr", 0 ; hdcDst

, "ptr", 0 ; *pptDst

, "ptr", 0 ; *psize

, "ptr", 0 ; hdcSrc

, "ptr", 0 ; *pptSrc

, "uint", 0 ; crKey

, "uint*", alpha << 16 | 0x01 << 24 ; *pblend

, "uint", 2 ; dwFlags

, "int") ; Success = 1

}

Hide() {

if (this.windowstate < 1)

return this

this.Invalidate()

this.FadeWindow(0)

this.CallEvent("Hide")

return this ; windowstate 1 ← x

}

Show() {

if (this.windowstate < 1)

return this

this.Validate()

this.FadeWindow(255)

this.CallEvent("Show")

return this ; windowstate x → 2|3

}

ShowHide() {

if (this.windowstate <= 1)

return this.Show()

if (this.windowstate >= 2)

return this.Hide()

}

Screenshot(filepath := "", quality := "") {

if (this.windowstate <= 1)

return this

this.ValidateWindow() ; Refresh window coordinates

pBitmap := TextRender.ScreenshotToBitmap([this.WindowLeft, this.WindowTop, this.WindowWidth, this.WindowHeight])

TextRender.BitmapToFile(pBitmap, filepath, quality)

DllCall("gdiplus\GdipDisposeImage", "ptr", pBitmap)

this.CallEvent("Screenshot")

return this

}

Free() {

if (this.bitmapstate <= 0)

return this

this.Erase()

this.FreeBitmap()

this.bitmapstate := 0 ; bitmapstate 0 ← x

this.CallEvent("Free")

return this

}

FreeBitmap() {

this.DeleteProp("ViewportLeft")

this.DeleteProp("ViewportTop")

this.DeleteProp("ViewportWidth")

this.DeleteProp("ViewportHeight")

this.DeleteProp("BitmapWidth")

this.DeleteProp("BitmapHeight")

this.DeleteProp("BitmapLeft")

this.DeleteProp("BitmapTop")

this.DeleteProp("BitmapRight")

this.DeleteProp("BitmapBottom")

DllCall("gdiplus\GdipDeleteGraphics", "ptr", this.Graphics)

obm := DllCall("CreateBitmap", "int", 0, "int", 0, "uint", 1, "uint", 1, "ptr", 0, "ptr")

DllCall("SelectObject", "ptr", this.hdc, "ptr", obm)

DllCall("DeleteObject", "ptr", this.hbm)

DllCall("DeleteDC", "ptr", this.hdc)

this.DeleteProp("hdc")

this.DeleteProp("hbm")

this.DeleteProp("ptr")

this.DeleteProp("size")

this.DeleteProp("width")

this.DeleteProp("height")

this.DeleteProp("Graphics")

}

Allocate(left := 0, top := 0, width := 0, height := 0) {

if (this.bitmapstate >= 1)

return this

this.AllocateBitmap(left := 0, top := 0, width := 0, height := 0)

this.bitmapstate := 1 ; bitmapstate x → 1

this.CallEvent("Allocate")

return this

}

AllocateBitmap(left := 0, top := 0, width := 0, height := 0) {

try dpi := DllCall("SetThreadDpiAwarenessContext", "ptr", -3, "ptr")

this.ViewportLeft := 0

this.ViewportTop := 0

this.ViewportWidth := A_ScreenWidth

this.ViewportHeight := A_ScreenHeight

try DllCall("SetThreadDpiAwarenessContext", "ptr", dpi, "ptr")

if !(width && height)

this.GetParentCoordinates(&left, &top, &width, &height)

this.BitmapLeft := left

this.BitmapTop := top

this.BitmapRight := left + width

this.BitmapBottom := top + height

this.BitmapWidth := width

this.BitmapHeight := height

hdc := DllCall("CreateCompatibleDC", "ptr", 0, "ptr")

bi := Buffer(40, 0) ; sizeof(bi) = 40

NumPut( "uint", 40, bi, 0) ; Size

NumPut( "int", width, bi, 4) ; Width

NumPut( "int", -height, bi, 8) ; Height - Negative so (0, 0) is top-left.

NumPut("ushort", 1, bi, 12) ; Planes

NumPut("ushort", 32, bi, 14) ; BitCount / BitsPerPixel

hbm := DllCall("CreateDIBSection", "ptr", hdc, "ptr", bi, "uint", 0, "ptr*", &pBits:=0, "ptr", 0, "uint", 0, "ptr")

obm := DllCall("SelectObject", "ptr", hdc, "ptr", hbm, "ptr")

DllCall("gdiplus\GdipCreateFromHDC", "ptr", hdc, "ptr*", &Graphics:=0)

DllCall("gdiplus\GdipTranslateWorldTransform", "ptr", Graphics, "float", -left, "float", -top, "int", 0)

this.hdc := hdc

this.hbm := hbm

this.ptr := pBits

this.size := 4 * width * height

this.width := width

this.height := height

this.Graphics := Graphics

}

Erase() {

if (this.bitmapstate <= 1)

return this

this.Recycle()

this.EraseBitmap()

this.bitmapstate := 1 ; bitmapstate 1 ← x

this.CallEvent("Erase")

return this

}

EraseBitmap() {

DllCall("gdiplus\GdipSetClipRect", "ptr", this.Graphics, "float", this.x, "float", this.y, "float", this.w, "float", this.h, "int", 0)

DllCall("gdiplus\GdipGraphicsClear", "ptr", this.Graphics, "uint", 0x00FFFFFF) ; All colors are the same speed.

DllCall("gdiplus\GdipResetClip", "ptr", this.Graphics)

this.DeleteProp("t")

this.DeleteProp("x")

this.DeleteProp("y")

this.DeleteProp("x2")

this.DeleteProp("y2")

this.DeleteProp("w")

this.DeleteProp("h")

this.DeleteProp("chars")

this.DeleteProp("words")

this.DeleteProp("lines")

}

Fill() {

if (this.bitmapstate >= 2)

return this

this.Allocate()

if (this.recipestate <= 0)

return this

this.FillBitmap()

this.bitmapstate := 2 ; bitmapstate x → 2 (if recipestate = 1)

this.CallEvent("Fill") ; bitmapstate x → 1 (if recipestate = 0)

return this

}

FillBitmap() {

for _, layer in this.layers

this.DrawBitmap(layer*)

}

DrawBitmap(data := "", style1 := "", style2 := "") {

dx := dy := 0

if this.HasProp("OriginLeft") && this.HasProp("OriginTop") {

DllCall("GetCursorPos", "ptr", point := Buffer(8))

dx := NumGet(point, 0, "int") - this.OriginLeft

dy := NumGet(point, 4, "int") - this.OriginTop

}

that := this.DrawOnGraphics(this.Graphics

, data

, style1

, style2

, this.ViewportWidth

, this.ViewportHeight

, this.ViewportLeft + dx

, this.ViewportTop + dy)

this.HasProp("t") && that.HasProp("t") ? this.t := max(this.t, that.t) : that.HasProp("t") && this.t := that.t

this.HasProp("x") && that.HasProp("x") ? this.x := min(this.x, that.x) : that.HasProp("x") && this.x := that.x

this.HasProp("y") && that.HasProp("y") ? this.y := min(this.y, that.y) : that.HasProp("y") && this.y := that.y

this.HasProp("x2") && that.HasProp("x2") ? this.x2 := max(this.x2, that.x2) : that.HasProp("x2") && this.x2 := that.x2

this.HasProp("y2") && that.HasProp("y2") ? this.y2 := max(this.y2, that.y2) : that.HasProp("y2") && this.y2 := that.y2

this.HasProp("x2") && this.HasProp("x") && this.w := this.x2 - this.x

this.HasProp("y2") && this.HasProp("y") && this.h := this.y2 - this.y

that.HasProp("chars") && this.chars := that.chars

that.HasProp("words") && this.words := that.words

that.HasProp("lines") && this.lines := that.lines

if !this.HasProp("w") || !this.HasProp("h")

throw Error("Contract Broken: User refused to cooperate with drawing something...")

}

Recycle() {

if (this.bitmapstate <= 2)

return this

this.bitmapstate := 2 ; bitmapstate 2 ← x

this.CallEvent("Recycle")

return this

}

Resolve() {

this.Fill()

if (this.bitmapstate == 1)

return this

this.bitmapstate := 3 ; bitmapstate x → 3 (if recipestate = 1)

this.CallEvent("Resolve") ; bitmapstate x → 1 (if recipestate = 0)

return this

}

Save(filepath := "", quality := "") {

if (this.recipestate >= 1) {

this.Redraw()

pBitmap := this.InBounds() ? this.CopyToBitmap() : this.RenderToBitmap()

}

if (this.recipestate <= 0) {

if (this.bitmapstate <= 1)

return this

pBitmap := this.CopyToBitmap()

}

TextRender.BitmapToFile(pBitmap, filepath, quality)

DllCall("gdiplus\GdipDisposeImage", "ptr", pBitmap)

this.CallEvent("Save") ; bitmapstate 2|3 if recipestate = 0 (1 of 2)

return this ; bitmapstate x → 2|3 ← x if recipestate = 1 (2 of 2)

}

Clear() {

this.Forget() ; recipestate 0 ← x

this.Erase() ; bitmapstate 1 ← x

this.Hide() ; windowstate 1 ← x

this.CallEvent("Clear")

return this

}

Timeout(status) {

if (this.status != status) ; windowstate a:x = b:x

return this

this.Destroy() ; windowstate 0 ← x

this.CallEvent("Timeout")

return this

}

Flush() {

if (this.recipestate <= 0)

return this

this.Reallocate()

this.Erase()

this.Fill()

this.Forget()

this.recipestate := 0 ; recipestate 0 ← x

this.bitmapstate := 2 ; bitmapstate x → 2 ← x

this.CallEvent("Flush")

return this

}

Paint() {

if (this.recipestate <= 0)

return this

this.Flush()

this.Resolve()

this.UpdateLayered()

this.Start()

this.recipestate := 0 ; recipestate 0 ← x

this.bitmapstate := 3 ; bitmapstate x → 3 ← x

this.windowstate := 3 ; windowstate x → 3 ← x

this.CallEvent("Paint")

return this

}

Draw(data := "", style1 := "", style2 := "") {

if (this.bitmapstate >= 3) {

this.Forget()

this.Erase()

}

this.Redraw()

this.Remember(data, style1, style2)

this.DrawBitmap(this.data, this.style1, this.style2)

this.bitmapstate := 2 ; bitmapstate x → 2 ← x

this.CallEvent("Draw") ; recipestate x → 1

return this

}

Render(data := "✿sentinel✿", styles*) {

if !(data == "✿sentinel✿")

this.Draw(data, styles*)

if (this.recipestate = 0)

throw Error("RecipeState is 0: Please pass drawing parameters here")

this.Reallocate()

this.Resolve()

this.UpdateLayered()

this.Start()

this.recipestate := 1 ; recipestate x → 1

this.bitmapstate := 3 ; bitmapstate x → 3

this.windowstate := 3 ; windowstate x → 3 ← x

this.CallEvent("Render")

return this

}

Reallocate() {

this.Allocate()

this.GetParentCoordinates(&left, &top, &width, &height)

if !(width = this.BitmapWidth && height = this.BitmapHeight) {

this.Free()

this.Allocate(left, top, width, height)

}

f := "Reallocate" ; bitmapstate x → 1|2|3 ← x (conditions 1 and 2 combined)

this.CallEvent(f) ; bitmapstate x → 1 ← x if screen size has changed (1 of 2)

return this ; bitmapstate x → 1|2|3 if screen size is the same (2 of 2)

}

Redraw() {

this.Reallocate()

if (this.recipestate == 0)

return this

this.Fill()

this.CallEvent("Redraw") ; bitmapstate x → 1|2|3 ← x if recipestate = 0 (1 of 2)

return this ; bitmapstate x → 2|3 ← x if recipestate = 1 (2 of 2)

}

Rerender() {

if (this.recipestate <= 0)

return this

if (this.bitmapstate <= 2)

return this

if (this.windowstate <= 0)

return this

this.Redraw()

this.Resolve()

this.UpdateLayered()

this.Resume()

this.windowstate := 3 ; windowstate 1|2|3 → 3

this.CallEvent("Rerender") ; recipestate 1

return this ; bitmapstate 3

}

TimeStamp() {

DllCall("QueryPerformanceCounter", "int64*", &start:=0)

return this.t0 := start

}

TimeElapsed() {

DllCall("QueryPerformanceFrequency", "int64*", &frequency:=0)

DllCall("QueryPerformanceCounter", "int64*", &end:=0)

return 1000 * (end - this.t0) / frequency

}

TimeRemaining() {

return max(0, this.WindowTime - this.TimeElapsed())

}

TimeExceeded() {

return min(0, this.TimeElapsed() - this.WindowTime)

}

StartTimer() {

this.Timer(this.WindowTime)

}

ResumeTimer() {

this.Timer(this.TimeRemaining())

}

StopTimer() {

this.status += 1

if 0xFFFF & this.status == 0xFFFF {

h := Random(0x1000, 0xFFFF)

l := 0

this.status := h << 32 | l

}

}

Timer(t, method := "Timeout") {

if (t > 0) {

f := ObjBindMethod(this, method, this.status) ; Calls Timeout()

SetTimer f, -t ; Calls __Delete.

}

}

Wait(t := 0) {

this.Cooldown() ; windowstate 2 ← x

this.Suspend(t) ; windowstate x

this.CallEvent("Wait")

return this

}

Cooldown() {

if (this.windowstate <= 1)

return this

this.Stop()

this.CooldownWindow()

this.windowstate := 2 ; windowstate 1|2 ← x

this.CallEvent("Cooldown")

return this

}

CooldownWindow() {

this.SuspendWindow(this.TimeRemaining())

}

Suspend(t := 0) {

this.SuspendWindow(t)

this.CallEvent("Suspend")

return this ; windowstate x

}

SuspendWindow(t := 0) {

if (t <= 0)

return

DllCall("QueryPerformanceFrequency", "int64*", &frequency:=0)

DllCall("QueryPerformanceCounter", "int64*", &start:=0)

loop {

DllCall("QueryPerformanceCounter", "int64*", &now:=0)

elapsed_time := (now - start) / frequency * 1000

remaining_time := t - elapsed_time

if (remaining_time > 30)

Sleep 10

if (remaining_time <= 0)

break

}

}

Animate(f, t, keyframes := "") {

if (this.bitmapstate <= 1)

return this