POLYGON V3 G

#NoEnv  ; Recommended for performance and compatibility with future AutoHotkey releases.
; #Warn  ; Enable warnings to assist with detecting common errors.
SendMode Input  ; Recommended for new scripts due to its superior speed and reliability.
SetWorkingDir %A_ScriptDir%  ; Ensures a consistent starting directory.

CoordMode,mouse,screen


;~ #Include,<hellbents_gdip>

 SetBatchLines,-1

 #MaxHotkeysPerInterval,10000000000

 popUp:=Layered_Window_SetUp(4,0,0,A_ScreenWidth,A_ScreenHeight,1,"Alwaysontop")

pointsmass:=[]
pBrush:=new_brush("000000")
backBrush:=new_brush("a00000","90")
point:={x:500,y:350}
loop {

    points:=""
    howmany := pointsmass.length() - 1
    Loop % HOWmany {
        points.= pointsmass[a_index].x  " , "  pointsmass[a_index].y " || "

    }
    points.= pointsmass[pointsmass.length()].x  " , "  pointsmass[pointsmass.length()].y

    gosub justDraw
    if(getkeystate("capslock","T"))
        break
    if(GetKeyState("lbutton")){
        MouseGetPos,x,y
        a:={x:x,y:y}

        PointsMass.insert(a.clone())

        loop {
            if(getkeystate("lbutton") = 0)
                break
        }

    }
}

howmany := pointsmass.length() - 1
massLines:=[]
loop % howmany {
    x1:=PointsMass[A_Index].x
    y1:=PointsMass[A_Index].y
    x2:=PointsMass[A_Index+1].x
    y2:=PointsMass[A_Index+1].y



    mass:={x1:x1,x2:x2,y2:y2,y1:y1}
    massLines.insert(mass.clone())
}

last := pointsmass.length()
x1:=PointsMass[last].x
y1:=PointsMass[last].y
x2:=PointsMass[1].x
y2:=PointsMass[1].y

mass:={x1:x1,x2:x2,y2:y2,y1:y1}
massLines.insert(mass.clone())



massValue:=[]
ANGLEVALUE:=[]
howmany := pointsmass.length()
;~ *******************

;~ *******************
loop % howmany {
    line:=massLines[a_index]
    massValue.insert(getValue(line,point))
    if(line.x1 = line.x2){
        if(point.x > line.x1)
            angle:=0
        else
            angle:=180
    }
    else {
        angle1:=getangle((line.y2 - line.y1)/(line.x2 - line.x1),-1)
        ;~ ANGLE2:=mod(angle1+180,360)
        angle0:=getangle(-line.x1 +point.x,-line.y1 + point.y)
        abs1:=abs(angle1 - angle0)
        ;~ abs2:=abs(angle2 - angle0)
        if(abs1 < 90)
            angle:=angle1
        else
            angle:=mod(angle1+180,360)
    }
    vals:={sin:sing(angle),cos:cosg(angle)}
    ANGLEVALUE.insert(vals.clone())



}

 ball1:= New BallClass(300,300,10,"a00000",50,20,0,1)

SetTimer,gameLoop,10
return


1::
SetTimer,gameLoop,10
return

2::
SetTimer,gameLoop,50
return
3::
SetTimer,gameLoop,150
return

justDraw:
Gdip_GraphicsClear(popUp.g)

Gdip_FillRectangle(popup.g,backBrush,0,0,popup.w,popup.h)

Gdip_FillPolygon(popup.g, pBrush, Points, 0)
fill_boxx(popup.g,"000000",POINT.x -5,point.y -5,10,10)



UpdateLayeredWindow(popUp.hwnd, popUp.hdc, popUp.x, popUp.y, popUp.w, popUp.h)














return
gameLoop:
SPEED:=10
BALL1.G/=SPEED
BALL1.VX/=10
BALL1.VY/=10
LOOP % SPEED {
    ball1.move()
    gosub checkOutside


}
BALL1.G*=SPEED
BALL1.VX*=10
BALL1.VY*=10
Gdip_GraphicsClear(popUp.g)

Gdip_FillRectangle(popup.g,backBrush,0,0,popup.w,popup.h)

Gdip_FillPolygon(popup.g, pBrush, Points, 0)

BALL1.DRAW(POPUP.G)

UpdateLayeredWindow(popUp.hwnd, popUp.hdc, popUp.x, popUp.y, popUp.w, popUp.h)
return


checkOutside:



out:=0

howmany := pointsmass.length()
loop % howmany {

    x:=ball1.x - ball1.r*ANGLEVALUE[A_INDEX].cos
    y:=ball1.y - ball1.r*ANGLEVALUE[A_INDEX].sin
    point:={x:x,y:y}
    line:=massLines[a_index]
    Value:=getValue(line,point)
    if(massValue[a_index] <> Value){
        ;~ ToolTip,% GETANGLE(ANGLEVALUE[A_INDEX].cos,ANGLEVALUE[A_INDEX].SIN)
        out:=A_Index
        break
    }




}
If(out <> 0){
        ball1.bump(massLines[out])
        ball1.x+=ball1.r*ANGLEVALUE[out].cos
        ball1.y+=ball1.r*ANGLEVALUE[out].sin
        ToolTip,% getangle(ANGLEVALUE[out].cos,ANGLEVALUE[out].sin)
        LOOP 1 {
            BALL1.MOVE()
        }
    }
;~ ToolTip,% BALL1.VX " " BALL1.VY
return

class BallClass {
    __New(X,Y,R,COLOUR,VX,VY,ANGLE,G){
        this.x:=x,this.y:=y,this.r:=r,this.colour:=colour,this.vx:=vx,this.vy:=vy,this.angle:=angle,this.g:=g
    }
    move(){
        this.vy+=this.g
        this.y+=this.vy
        this.x+=this.vx
    }
    draw(g){
        Fill_ellipse(g,this.colour,this.x - this.r,this.y - this.r,2*this.r,2*this.r)
    }

    bump(LINE){

        if(line.x1 = line.x2){
            this.vx:= - this.vx
            return
        }

        angleNorm:=getangle((line.y2 - line.y1)/(line.x2 - line.x1),-1)

        angleSpeed:=getAngle(this.vx, this.vy)
        brandNewAngle:= 180 + 2*angleNorm - angleSpeed
        v:=Sqrt(THIS.vx**2 + THIS.vy**2)
        THIS.angle:=brandNewAngle
        this.vx:=v*cosg(brandNewAngle)
        this.vy:=v*sing(brandNewAngle)

    }

}

getValue(line,point){
    x:=point.x,y:=point.y
    x1:=line.x1,y1:=line.y1,x2:=line.x2,y2:=line.y2
    if(x1 = x2){
        if(x > x1)
            return 1
        else if(x <= x1)
            return -1
    }
    else if (x1 <> x2){
        val:= y - (y1 + ((y2-y1)/(x2-x1) )*(x-x1))
        if(val = 0)
            return -1
        return val/abs(val)
    }





}



getAngle(dx,dy){
    r:=Sqrt(dx**2 + dy**2)
    if(dx>=0)
        angle:= asinG(dy/r)
    else if(dy>=0)
        angle:= acosG(dx/r)
    else if(dx < 0 && dy < 0)
        angle:= 180 + asing(abs(dy/r))
    if(angle < 0)
        angle+=360
    return angle
}


x::
gosub getOutOfHere
return

getOutOfHere:
ExitApp
Layered_Window_ShutDown(popUp)
return












;STUFF  Hellbent HAS  added
;&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
;&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
;&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

Layered_Window_SetUp(Smoothing,Window_X,Window_Y,Window_W,Window_H,Window_Name:=1,Window_Options:="")
    {
        Layered:={}
        Layered.W:=Window_W
        Layered.H:=Window_H
        Layered.X:=Window_X
        Layered.Y:=Window_Y
        Layered.Name:=Window_Name
        Layered.Options:=Window_Options
        Layered.Token:=Gdip_Startup()
        Create_Layered_GUI(Layered)
        Layered.hwnd:=winExist()
        Layered.hbm := CreateDIBSection(Window_W,Window_H)
        Layered.hdc := CreateCompatibleDC()
        Layered.obm := SelectObject(Layered.hdc,Layered.hbm)
        Layered.G := Gdip_GraphicsFromHDC(Layered.hdc)
        Gdip_SetSmoothingMode(Layered.G,Smoothing)
        return Layered
    }

Create_Layered_GUI(Layered)
    {
        Gui,% Layered.Name ": +E0x80000 +LastFound " Layered.Options
        Gui,% Layered.Name ":Show",% "x" Layered.X " y" Layered.Y " w" Layered.W " h" Layered.H " NA"
    }

Layered_Window_ShutDown(This)
    {
        SelectObject(This.hdc,This.obm)
        DeleteObject(This.hbm)
        DeleteDC(This.hdc)
        gdip_deleteGraphics(This.g)
        Gdip_Shutdown(This.Token)
    }

Gdip_RotateBitmap(pBitmap, Angle, Dispose=1) { ; returns rotated bitmap. By Learning one.
Gdip_GetImageDimensions(pBitmap, Width, Height)
Gdip_GetRotatedDimensions(Width, Height, Angle, RWidth, RHeight)
Gdip_GetRotatedTranslation(Width, Height, Angle, xTranslation, yTranslation)

pBitmap2 := Gdip_CreateBitmap(RWidth, RHeight)
G2 := Gdip_GraphicsFromImage(pBitmap2), Gdip_SetSmoothingMode(G2, 4), Gdip_SetInterpolationMode(G2, 7)
Gdip_TranslateWorldTransform(G2, xTranslation, yTranslation)
Gdip_RotateWorldTransform(G2, Angle)
Gdip_DrawImage(G2, pBitmap, 0, 0, Width, Height)

Gdip_ResetWorldTransform(G2)
Gdip_DeleteGraphics(G2)
if Dispose
Gdip_DisposeImage(pBitmap)
return pBitmap2
}

New_Brush(colour:="000000",Alpha:="FF")
    {
        static Hellbent_Brush:=[]
        new_colour := "0x" Alpha colour
        Hellbent_Brush[Hellbent_Brush.Length()+1]:=Gdip_BrushCreateSolid(new_colour)
        return Hellbent_Brush[Hellbent_Brush.Length()]
    }


New_Pen(colour:="000000",Alpha:="FF",Width:= 5)
    {
        static Hellbent_Pen:=[]
        new_colour := "0x" Alpha colour
        Hellbent_Pen[Hellbent_Pen.Length()+1]:=Gdip_CreatePen(New_Colour,Width)
        return Hellbent_Pen[Hellbent_Pen.Length()]
    }

Fill_Box(pGraphics,pBrush,x,y,w,h)
    {
        ;~ Gdip_FillRectangle(G, Brush, x, y, w, h)
        Ptr := A_PtrSize ? "UPtr" : "UInt"

        return DllCall("gdiplus\GdipFillRectangle"
                    , Ptr, pGraphics
                    , Ptr, pBrush
                    , "float", x
                    , "float", y
                    , "float", w
                    , "float", h)
    }
Fill_Boxx(pGraphics,colour,x,y,w,h){
    pBrush:=new_brush(colour)
Fill_Box(pGraphics,pBrush,x,y,w,h)
}
;&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
;&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
;&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

atang(tann){
    angle:=ATan(tann)
    angle:=angle/(3.14159265359/180)
    return angle
}
tang(angle){
    return tan(angle*(3.14159265359/180))
}





turn_bitmap(byref xbitmap,xturn){
xWidth := Gdip_GetImageWidth(xbitmap)
xHeight := Gdip_GetImageHeight(xbitmap)


Gdip_GetRotatedDimensions(xWidth, xHeight, xturn, xRWidth, xRHeight)
;~ MsgBox,% "Rwidth: " RWidth "`nrheight: " rheight

; xTranslation and yTranslation now contain the distance to shift the image by
Gdip_GetRotatedTranslation(xWidth, xHeight, xturn, xxTranslation, xyTranslation)
;~ MsgBox,% "xTranslation: " xTranslation "`nyTranslation: " yTranslation
xpBitmap := Gdip_CreateBitmap(xRWidth, xRHeight)                       ; Create a new bitmap
xg := Gdip_GraphicsFromImage(xpBitmap)                                ; Get a pointer to the graphics of the bitmap
Gdip_SetSmoothingMode(xg, 4)

Gdip_SetInterpolationMode(xg, 7)
Gdip_TranslateWorldTransform(xg, xxTranslation, xyTranslation)
Gdip_RotateWorldTransform(xg, xturn)


Gdip_DrawImage(xg, xbitmap, 0,0, xWidth, xHeight)
Gdip_ResetWorldTransform(xg)

xbitmap:=xpbitmap
}

turn_in_graphics(byref xg,xx,xy,xturn,xbitmap){

    turn_bitmap(xbitmap,xturn)
    xWidth := Gdip_GetImageWidth(xbitmap)
xHeight := Gdip_GetImageHeight(xbitmap)
    Gdip_DrawImage(xG, xBitmap, xx-xWidth/2, xy-xheight/2, xWidth, xHeight)

}
fill_ellipse(g,colour,x1,y1,w,h){
        pBrush:=new_brush(colour)
    Gdip_FillEllipse(g, pBrush, x1, y1, w, h)

}

sinG(x){
return sin(x*3.14159265359/180)
}
asinG(sinn){
    angle:=Asin(sinn)
    angle:=angle/(3.14159265359/180)
    return angle
}


acosG(coss){
    angle:=Acos(coss)
    angle:=angle/(3.14159265359/180)
    return angle
}



cosG(x){
return cos(x*3.14159265359/180)
}
/*
two new functions and an opportunity to change

GDIP_SCALE(Map,SCALE)
; map you want to get a changed copy that is scale times less than
original one
fileScale(sFile,newName,SCALE)
;saves a changed( scale times less copy) of image from sfile Path
to newname Path
*/
GDIP_SCALE(Map,SCALE){
Gdip_GetImageDimensions(MAP,  wOrig,  hOrig)
newSize:={w:wOrig//SCALE,h:hOrig//SCALE}

newMap := Gdip_CreateBitmap(newSize.w, newSize.h)
newMapG := Gdip_GraphicsFromImage(newMap)
Gdip_SetSmoothingMode(newMapG, 4)
Gdip_DrawImage(newMapG, map, 0, 0 ,newSize.w,newSize.h,0,0,wOrig,hOrig)
return newMap


}

fileScale(sFile,newName,SCALE){
    map:=Gdip_CreateBitmapFromFile(sfile)
    newmap:=GDIP_SCALE(Map,SCALE)
    Gdip_SaveBitmapToFile(newmap, newname)
}



        ;~ split(string){
    ;~ string := StrSplit(string, A_Space)
    ;~ t:=1
    ;~ while ( string.length() >= t) {
        ;~ if(string[t]<>"")
            ;~ t++
        ;~ else
            ;~ string.Remove(t)
    ;~ }
    ;~ return string
;~ }








; Gdip standard library v1.45 by tic (Tariq Porter) 07/09/11
; Modifed by Rseding91 using fincs 64 bit compatible Gdip library 5/1/2013
; Supports: Basic, _L ANSi, _L Unicode x86 and _L Unicode x64
;
; Updated 2/20/2014 - fixed Gdip_CreateRegion() and Gdip_GetClipRegion() on AHK Unicode x86
; Updated 5/13/2013 - fixed Gdip_SetBitmapToClipboard() on AHK Unicode x64
;
;#####################################################################################
;#####################################################################################
; STATUS ENUMERATION
; Return values for functions specified to have status enumerated return type
;#####################################################################################
;
; Ok =                      = 0
; GenericError              = 1
; InvalidParameter          = 2
; OutOfMemory               = 3
; ObjectBusy                = 4
; InsufficientBuffer        = 5
; NotImplemented            = 6
; Win32Error                = 7
; WrongState                = 8
; Aborted                   = 9
; FileNotFound              = 10
; ValueOverflow             = 11
; AccessDenied              = 12
; UnknownImageFormat        = 13
; FontFamilyNotFound        = 14
; FontStyleNotFound         = 15
; NotTrueTypeFont           = 16
; UnsupportedGdiplusVersion = 17
; GdiplusNotInitialized     = 18
; PropertyNotFound          = 19
; PropertyNotSupported      = 20
; ProfileNotFound           = 21
;
;#####################################################################################
;#####################################################################################
; FUNCTIONS
;#####################################################################################
;
; UpdateLayeredWindow(hwnd, hdc, x="", y="", w="", h="", Alpha=255)
; BitBlt(ddc, dx, dy, dw, dh, sdc, sx, sy, Raster="")
; StretchBlt(dDC, dx, dy, dw, dh, sDC, sx, sy, sw, sh, Raster="")
; SetImage(hwnd, hBitmap)
; Gdip_BitmapFromScreen(Screen=0, Raster="")
; CreateRectF(ByRef RectF, x, y, w, h)
; CreateSizeF(ByRef SizeF, w, h)
; CreateDIBSection
;
;#####################################################################################

; Function:                 UpdateLayeredWindow
; Description:              Updates a layered window with the handle to the DC of a gdi bitmap
;
; hwnd                      Handle of the layered window to update
; hdc                       Handle to the DC of the GDI bitmap to update the window with
; Layeredx                  x position to place the window
; Layeredy                  y position to place the window
; Layeredw                  Width of the window
; Layeredh                  Height of the window
; Alpha                     Default = 255 : The transparency (0-255) to set the window transparency
;
; return                    If the function succeeds, the return value is nonzero
;
; notes                     If x or y omitted, then layered window will use its current coordinates
;                           If w or h omitted then current width and height will be used

UpdateLayeredWindow(hwnd, hdc, x="", y="", w="", h="", Alpha=255)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    if ((x != "") && (y != ""))
        VarSetCapacity(pt, 8), NumPut(x, pt, 0, "UInt"), NumPut(y, pt, 4, "UInt")

    if (w = "") ||(h = "")
        WinGetPos,,, w, h, ahk_id %hwnd%

    return DllCall("UpdateLayeredWindow"
                    , Ptr, hwnd
                    , Ptr, 0
                    , Ptr, ((x = "") && (y = "")) ? 0 : &pt
                    , "int64*", w|h<<32
                    , Ptr, hdc
                    , "int64*", 0
                    , "uint", 0
                    , "UInt*", Alpha<<16|1<<24
                    , "uint", 2)
}

;#####################################################################################

; Function              BitBlt
; Description           The BitBlt function performs a bit-block transfer of the color data corresponding to a rectangle
;                       of pixels from the specified source device context into a destination device context.
;
; dDC                   handle to destination DC
; dx                    x-coord of destination upper-left corner
; dy                    y-coord of destination upper-left corner
; dw                    width of the area to copy
; dh                    height of the area to copy
; sDC                   handle to source DC
; sx                    x-coordinate of source upper-left corner
; sy                    y-coordinate of source upper-left corner
; Raster                raster operation code
;
; return                If the function succeeds, the return value is nonzero
;
; notes                 If no raster operation is specified, then SRCCOPY is used, which copies the source directly to the destination rectangle
;
; BLACKNESS             = 0x00000042
; NOTSRCERASE           = 0x001100A6
; NOTSRCCOPY            = 0x00330008
; SRCERASE              = 0x00440328
; DSTINVERT             = 0x00550009
; PATINVERT             = 0x005A0049
; SRCINVERT             = 0x00660046
; SRCAND                = 0x008800C6
; MERGEPAINT            = 0x00BB0226
; MERGECOPY             = 0x00C000CA
; SRCCOPY               = 0x00CC0020
; SRCPAINT              = 0x00EE0086
; PATCOPY               = 0x00F00021
; PATPAINT              = 0x00FB0A09
; WHITENESS             = 0x00FF0062
; CAPTUREBLT            = 0x40000000
; NOMIRRORBITMAP        = 0x80000000

BitBlt(ddc, dx, dy, dw, dh, sdc, sx, sy, Raster="")
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    return DllCall("gdi32\BitBlt"
                    , Ptr, dDC
                    , "int", dx
                    , "int", dy
                    , "int", dw
                    , "int", dh
                    , Ptr, sDC
                    , "int", sx
                    , "int", sy
                    , "uint", Raster ? Raster : 0x00CC0020)
}

;#####################################################################################

; Function              StretchBlt
; Description           The StretchBlt function copies a bitmap from a source rectangle into a destination rectangle,
;                       stretching or compressing the bitmap to fit the dimensions of the destination rectangle, if necessary.
;                       The system stretches or compresses the bitmap according to the stretching mode currently set in the destination device context.
;
; ddc                   handle to destination DC
; dx                    x-coord of destination upper-left corner
; dy                    y-coord of destination upper-left corner
; dw                    width of destination rectangle
; dh                    height of destination rectangle
; sdc                   handle to source DC
; sx                    x-coordinate of source upper-left corner
; sy                    y-coordinate of source upper-left corner
; sw                    width of source rectangle
; sh                    height of source rectangle
; Raster                raster operation code
;
; return                If the function succeeds, the return value is nonzero
;
; notes                 If no raster operation is specified, then SRCCOPY is used. It uses the same raster operations as BitBlt

StretchBlt(ddc, dx, dy, dw, dh, sdc, sx, sy, sw, sh, Raster="")
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    return DllCall("gdi32\StretchBlt"
                    , Ptr, ddc
                    , "int", dx
                    , "int", dy
                    , "int", dw
                    , "int", dh
                    , Ptr, sdc
                    , "int", sx
                    , "int", sy
                    , "int", sw
                    , "int", sh
                    , "uint", Raster ? Raster : 0x00CC0020)
}

;#####################################################################################

; Function              SetStretchBltMode
; Description           The SetStretchBltMode function sets the bitmap stretching mode in the specified device context
;
; hdc                   handle to the DC
; iStretchMode          The stretching mode, describing how the target will be stretched
;
; return                If the function succeeds, the return value is the previous stretching mode. If it fails it will return 0
;
; STRETCH_ANDSCANS      = 0x01
; STRETCH_ORSCANS       = 0x02
; STRETCH_DELETESCANS   = 0x03
; STRETCH_HALFTONE      = 0x04

SetStretchBltMode(hdc, iStretchMode=4)
{
    return DllCall("gdi32\SetStretchBltMode"
                    , A_PtrSize ? "UPtr" : "UInt", hdc
                    , "int", iStretchMode)
}

;#####################################################################################

; Function              SetImage
; Description           Associates a new image with a static control
;
; hwnd                  handle of the control to update
; hBitmap               a gdi bitmap to associate the static control with
;
; return                If the function succeeds, the return value is nonzero

SetImage(hwnd, hBitmap)
{
    SendMessage, 0x172, 0x0, hBitmap,, ahk_id %hwnd%
    E := ErrorLevel
    DeleteObject(E)
    return E
}

;#####################################################################################

; Function              SetSysColorToControl
; Description           Sets a solid colour to a control
;
; hwnd                  handle of the control to update
; SysColor              A system colour to set to the control
;
; return                If the function succeeds, the return value is zero
;
; notes                 A control must have the 0xE style set to it so it is recognised as a bitmap
;                       By default SysColor=15 is used which is COLOR_3DFACE. This is the standard background for a control
;
; COLOR_3DDKSHADOW              = 21
; COLOR_3DFACE                  = 15
; COLOR_3DHIGHLIGHT             = 20
; COLOR_3DHILIGHT               = 20
; COLOR_3DLIGHT                 = 22
; COLOR_3DSHADOW                = 16
; COLOR_ACTIVEBORDER            = 10
; COLOR_ACTIVECAPTION           = 2
; COLOR_APPWORKSPACE            = 12
; COLOR_BACKGROUND              = 1
; COLOR_BTNFACE                 = 15
; COLOR_BTNHIGHLIGHT            = 20
; COLOR_BTNHILIGHT              = 20
; COLOR_BTNSHADOW               = 16
; COLOR_BTNTEXT                 = 18
; COLOR_CAPTIONTEXT             = 9
; COLOR_DESKTOP                 = 1
; COLOR_GRADIENTACTIVECAPTION   = 27
; COLOR_GRADIENTINACTIVECAPTION = 28
; COLOR_GRAYTEXT                = 17
; COLOR_HIGHLIGHT               = 13
; COLOR_HIGHLIGHTTEXT           = 14
; COLOR_HOTLIGHT                = 26
; COLOR_INACTIVEBORDER          = 11
; COLOR_INACTIVECAPTION         = 3
; COLOR_INACTIVECAPTIONTEXT     = 19
; COLOR_INFOBK                  = 24
; COLOR_INFOTEXT                = 23
; COLOR_MENU                    = 4
; COLOR_MENUHILIGHT             = 29
; COLOR_MENUBAR                 = 30
; COLOR_MENUTEXT                = 7
; COLOR_SCROLLBAR               = 0
; COLOR_WINDOW                  = 5
; COLOR_WINDOWFRAME             = 6
; COLOR_WINDOWTEXT              = 8

SetSysColorToControl(hwnd, SysColor=15)
{
   WinGetPos,,, w, h, ahk_id %hwnd%
   bc := DllCall("GetSysColor", "Int", SysColor, "UInt")
   pBrushClear := Gdip_BrushCreateSolid(0xff000000 | (bc >> 16 | bc & 0xff00 | (bc & 0xff) << 16))
   pBitmap := Gdip_CreateBitmap(w, h), G := Gdip_GraphicsFromImage(pBitmap)
   Gdip_FillRectangle(G, pBrushClear, 0, 0, w, h)
   hBitmap := Gdip_CreateHBITMAPFromBitmap(pBitmap)
   SetImage(hwnd, hBitmap)
   Gdip_DeleteBrush(pBrushClear)
   Gdip_DeleteGraphics(G), Gdip_DisposeImage(pBitmap), DeleteObject(hBitmap)
   return 0
}

;#####################################################################################

; Function              Gdip_BitmapFromScreen
; Description           Gets a gdi+ bitmap from the screen
;
; Screen                0 = All screens
;                       Any numerical value = Just that screen
;                       x|y|w|h = Take specific coordinates with a width and height
; Raster                raster operation code
;
; return                If the function succeeds, the return value is a pointer to a gdi+ bitmap
;                       -1:     one or more of x,y,w,h not passed properly
;
; notes                 If no raster operation is specified, then SRCCOPY is used to the returned bitmap

Gdip_BitmapFromScreen(Screen=0, Raster="")
{
    if (Screen = 0)
    {
        Sysget, x, 76
        Sysget, y, 77
        Sysget, w, 78
        Sysget, h, 79
    }
    else if (SubStr(Screen, 1, 5) = "hwnd:")
    {
        Screen := SubStr(Screen, 6)
        if !WinExist( "ahk_id " Screen)
            return -2
        WinGetPos,,, w, h, ahk_id %Screen%
        x := y := 0
        hhdc := GetDCEx(Screen, 3)
    }
    else if (Screen&1 != "")
    {
        Sysget, M, Monitor, %Screen%
        x := MLeft, y := MTop, w := MRight-MLeft, h := MBottom-MTop
    }
    else
    {
        StringSplit, S, Screen, |
        x := S1, y := S2, w := S3, h := S4
    }

    if (x = "") || (y = "") || (w = "") || (h = "")
        return -1

    chdc := CreateCompatibleDC(), hbm := CreateDIBSection(w, h, chdc), obm := SelectObject(chdc, hbm), hhdc := hhdc ? hhdc : GetDC()
    BitBlt(chdc, 0, 0, w, h, hhdc, x, y, Raster)
    ReleaseDC(hhdc)

    pBitmap := Gdip_CreateBitmapFromHBITMAP(hbm)
    SelectObject(chdc, obm), DeleteObject(hbm), DeleteDC(hhdc), DeleteDC(chdc)
    return pBitmap
}

;#####################################################################################

; Function              Gdip_BitmapFromHWND
; Description           Uses PrintWindow to get a handle to the specified window and return a bitmap from it
;
; hwnd                  handle to the window to get a bitmap from
;
; return                If the function succeeds, the return value is a pointer to a gdi+ bitmap
;
; notes                 Window must not be not minimised in order to get a handle to it's client area

Gdip_BitmapFromHWND(hwnd)
{
    WinGetPos,,, Width, Height, ahk_id %hwnd%
    hbm := CreateDIBSection(Width, Height), hdc := CreateCompatibleDC(), obm := SelectObject(hdc, hbm)
    PrintWindow(hwnd, hdc)
    pBitmap := Gdip_CreateBitmapFromHBITMAP(hbm)
    SelectObject(hdc, obm), DeleteObject(hbm), DeleteDC(hdc)
    return pBitmap
}

;#####################################################################################

; Function              CreateRectF
; Description           Creates a RectF object, containing a the coordinates and dimensions of a rectangle
;
; RectF                 Name to call the RectF object
; x                     x-coordinate of the upper left corner of the rectangle
; y                     y-coordinate of the upper left corner of the rectangle
; w                     Width of the rectangle
; h                     Height of the rectangle
;
; return                No return value

CreateRectF(ByRef RectF, x, y, w, h)
{
   VarSetCapacity(RectF, 16)
   NumPut(x, RectF, 0, "float"), NumPut(y, RectF, 4, "float"), NumPut(w, RectF, 8, "float"), NumPut(h, RectF, 12, "float")
}

;#####################################################################################

; Function              CreateRect
; Description           Creates a Rect object, containing a the coordinates and dimensions of a rectangle
;
; RectF                 Name to call the RectF object
; x                     x-coordinate of the upper left corner of the rectangle
; y                     y-coordinate of the upper left corner of the rectangle
; w                     Width of the rectangle
; h                     Height of the rectangle
;
; return                No return value

CreateRect(ByRef Rect, x, y, w, h)
{
    VarSetCapacity(Rect, 16)
    NumPut(x, Rect, 0, "uint"), NumPut(y, Rect, 4, "uint"), NumPut(w, Rect, 8, "uint"), NumPut(h, Rect, 12, "uint")
}
;#####################################################################################

; Function              CreateSizeF
; Description           Creates a SizeF object, containing an 2 values
;
; SizeF                 Name to call the SizeF object
; w                     w-value for the SizeF object
; h                     h-value for the SizeF object
;
; return                No Return value

CreateSizeF(ByRef SizeF, w, h)
{
   VarSetCapacity(SizeF, 8)
   NumPut(w, SizeF, 0, "float"), NumPut(h, SizeF, 4, "float")
}
;#####################################################################################

; Function              CreatePointF
; Description           Creates a SizeF object, containing an 2 values
;
; SizeF                 Name to call the SizeF object
; w                     w-value for the SizeF object
; h                     h-value for the SizeF object
;
; return                No Return value

CreatePointF(ByRef PointF, x, y)
{
   VarSetCapacity(PointF, 8)
   NumPut(x, PointF, 0, "float"), NumPut(y, PointF, 4, "float")
}
;#####################################################################################

; Function              CreateDIBSection
; Description           The CreateDIBSection function creates a DIB (Device Independent Bitmap) that applications can write to directly
;
; w                     width of the bitmap to create
; h                     height of the bitmap to create
; hdc                   a handle to the device context to use the palette from
; bpp                   bits per pixel (32 = ARGB)
; ppvBits               A pointer to a variable that receives a pointer to the location of the DIB bit values
;
; return                returns a DIB. A gdi bitmap
;
; notes                 ppvBits will receive the location of the pixels in the DIB

CreateDIBSection(w, h, hdc="", bpp=32, ByRef ppvBits=0)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    hdc2 := hdc ? hdc : GetDC()
    VarSetCapacity(bi, 40, 0)

    NumPut(w, bi, 4, "uint")
    , NumPut(h, bi, 8, "uint")
    , NumPut(40, bi, 0, "uint")
    , NumPut(1, bi, 12, "ushort")
    , NumPut(0, bi, 16, "uInt")
    , NumPut(bpp, bi, 14, "ushort")

    hbm := DllCall("CreateDIBSection"
                    , Ptr, hdc2
                    , Ptr, &bi
                    , "uint", 0
                    , A_PtrSize ? "UPtr*" : "uint*", ppvBits
                    , Ptr, 0
                    , "uint", 0, Ptr)

    if !hdc
        ReleaseDC(hdc2)
    return hbm
}

;#####################################################################################

; Function              PrintWindow
; Description           The PrintWindow function copies a visual window into the specified device context (DC), typically a printer DC
;
; hwnd                  A handle to the window that will be copied
; hdc                   A handle to the device context
; Flags                 Drawing options
;
; return                If the function succeeds, it returns a nonzero value
;
; PW_CLIENTONLY         = 1

PrintWindow(hwnd, hdc, Flags=0)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    return DllCall("PrintWindow", Ptr, hwnd, Ptr, hdc, "uint", Flags)
}

;#####################################################################################

; Function              DestroyIcon
; Description           Destroys an icon and frees any memory the icon occupied
;
; hIcon                 Handle to the icon to be destroyed. The icon must not be in use
;
; return                If the function succeeds, the return value is nonzero

DestroyIcon(hIcon)
{
    return DllCall("DestroyIcon", A_PtrSize ? "UPtr" : "UInt", hIcon)
}

;#####################################################################################

PaintDesktop(hdc)
{
    return DllCall("PaintDesktop", A_PtrSize ? "UPtr" : "UInt", hdc)
}

;#####################################################################################

CreateCompatibleBitmap(hdc, w, h)
{
    return DllCall("gdi32\CreateCompatibleBitmap", A_PtrSize ? "UPtr" : "UInt", hdc, "int", w, "int", h)
}

;#####################################################################################

; Function              CreateCompatibleDC
; Description           This function creates a memory device context (DC) compatible with the specified device
;
; hdc                   Handle to an existing device context
;
; return                returns the handle to a device context or 0 on failure
;
; notes                 If this handle is 0 (by default), the function creates a memory device context compatible with the application's current screen

CreateCompatibleDC(hdc=0)
{
   return DllCall("CreateCompatibleDC", A_PtrSize ? "UPtr" : "UInt", hdc)
}

;#####################################################################################

; Function              SelectObject
; Description           The SelectObject function selects an object into the specified device context (DC). The new object replaces the previous object of the same type
;
; hdc                   Handle to a DC
; hgdiobj               A handle to the object to be selected into the DC
;
; return                If the selected object is not a region and the function succeeds, the return value is a handle to the object being replaced
;
; notes                 The specified object must have been created by using one of the following functions
;                       Bitmap - CreateBitmap, CreateBitmapIndirect, CreateCompatibleBitmap, CreateDIBitmap, CreateDIBSection (A single bitmap cannot be selected into more than one DC at the same time)
;                       Brush - CreateBrushIndirect, CreateDIBPatternBrush, CreateDIBPatternBrushPt, CreateHatchBrush, CreatePatternBrush, CreateSolidBrush
;                       Font - CreateFont, CreateFontIndirect
;                       Pen - CreatePen, CreatePenIndirect
;                       Region - CombineRgn, CreateEllipticRgn, CreateEllipticRgnIndirect, CreatePolygonRgn, CreateRectRgn, CreateRectRgnIndirect
;
; notes                 If the selected object is a region and the function succeeds, the return value is one of the following value
;
; SIMPLEREGION          = 2 Region consists of a single rectangle
; COMPLEXREGION         = 3 Region consists of more than one rectangle
; NULLREGION            = 1 Region is empty

SelectObject(hdc, hgdiobj)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    return DllCall("SelectObject", Ptr, hdc, Ptr, hgdiobj)
}

;#####################################################################################

; Function              DeleteObject
; Description           This function deletes a logical pen, brush, font, bitmap, region, or palette, freeing all system resources associated with the object
;                       After the object is deleted, the specified handle is no longer valid
;
; hObject               Handle to a logical pen, brush, font, bitmap, region, or palette to delete
;
; return                Nonzero indicates success. Zero indicates that the specified handle is not valid or that the handle is currently selected into a device context

DeleteObject(hObject)
{
   return DllCall("DeleteObject", A_PtrSize ? "UPtr" : "UInt", hObject)
}

;#####################################################################################

; Function              GetDC
; Description           This function retrieves a handle to a display device context (DC) for the client area of the specified window.
;                       The display device context can be used in subsequent graphics display interface (GDI) functions to draw in the client area of the window.
;
; hwnd                  Handle to the window whose device context is to be retrieved. If this value is NULL, GetDC retrieves the device context for the entire screen
;
; return                The handle the device context for the specified window's client area indicates success. NULL indicates failure

GetDC(hwnd=0)
{
    return DllCall("GetDC", A_PtrSize ? "UPtr" : "UInt", hwnd)
}

;#####################################################################################

; DCX_CACHE = 0x2
; DCX_CLIPCHILDREN = 0x8
; DCX_CLIPSIBLINGS = 0x10
; DCX_EXCLUDERGN = 0x40
; DCX_EXCLUDEUPDATE = 0x100
; DCX_INTERSECTRGN = 0x80
; DCX_INTERSECTUPDATE = 0x200
; DCX_LOCKWINDOWUPDATE = 0x400
; DCX_NORECOMPUTE = 0x100000
; DCX_NORESETATTRS = 0x4
; DCX_PARENTCLIP = 0x20
; DCX_VALIDATE = 0x200000
; DCX_WINDOW = 0x1

GetDCEx(hwnd, flags=0, hrgnClip=0)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    return DllCall("GetDCEx", Ptr, hwnd, Ptr, hrgnClip, "int", flags)
}

;#####################################################################################

; Function              ReleaseDC
; Description           This function releases a device context (DC), freeing it for use by other applications. The effect of ReleaseDC depends on the type of device context
;
; hdc                   Handle to the device context to be released
; hwnd                  Handle to the window whose device context is to be released
;
; return                1 = released
;                       0 = not released
;
; notes                 The application must call the ReleaseDC function for each call to the GetWindowDC function and for each call to the GetDC function that retrieves a common device context
;                       An application cannot use the ReleaseDC function to release a device context that was created by calling the CreateDC function; instead, it must use the DeleteDC function.

ReleaseDC(hdc, hwnd=0)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    return DllCall("ReleaseDC", Ptr, hwnd, Ptr, hdc)
}

;#####################################################################################

; Function              DeleteDC
; Description           The DeleteDC function deletes the specified device context (DC)
;
; hdc                   A handle to the device context
;
; return                If the function succeeds, the return value is nonzero
;
; notes                 An application must not delete a DC whose handle was obtained by calling the GetDC function. Instead, it must call the ReleaseDC function to free the DC

DeleteDC(hdc)
{
   return DllCall("DeleteDC", A_PtrSize ? "UPtr" : "UInt", hdc)
}
;#####################################################################################

; Function              Gdip_LibraryVersion
; Description           Get the current library version
;
; return                the library version
;
; notes                 This is useful for non compiled programs to ensure that a person doesn't run an old version when testing your scripts

Gdip_LibraryVersion()
{
    return 1.45
}

;#####################################################################################

; Function              Gdip_LibrarySubVersion
; Description           Get the current library sub version
;
; return                the library sub version
;
; notes                 This is the sub-version currently maintained by Rseding91
Gdip_LibrarySubVersion()
{
    return 1.47
}

;#####################################################################################

; Function:             Gdip_BitmapFromBRA
; Description:          Gets a pointer to a gdi+ bitmap from a BRA file
;
; BRAFromMemIn          The variable for a BRA file read to memory
; File                  The name of the file, or its number that you would like (This depends on alternate parameter)
; Alternate             Changes whether the File parameter is the file name or its number
;
; return                If the function succeeds, the return value is a pointer to a gdi+ bitmap
;                       -1 = The BRA variable is empty
;                       -2 = The BRA has an incorrect header
;                       -3 = The BRA has information missing
;                       -4 = Could not find file inside the BRA

Gdip_BitmapFromBRA(ByRef BRAFromMemIn, File, Alternate=0)
{
    Static FName = "ObjRelease"

    if !BRAFromMemIn
        return -1
    Loop, Parse, BRAFromMemIn, `n
    {
        if (A_Index = 1)
        {
            StringSplit, Header, A_LoopField, |
            if (Header0 != 4 || Header2 != "BRA!")
                return -2
        }
        else if (A_Index = 2)
        {
            StringSplit, Info, A_LoopField, |
            if (Info0 != 3)
                return -3
        }
        else
            break
    }
    if !Alternate
        StringReplace, File, File, \, \\, All
    RegExMatch(BRAFromMemIn, "mi`n)^" (Alternate ? File "\|.+?\|(\d+)\|(\d+)" : "\d+\|" File "\|(\d+)\|(\d+)") "$", FileInfo)
    if !FileInfo
        return -4

    hData := DllCall("GlobalAlloc", "uint", 2, Ptr, FileInfo2, Ptr)
    pData := DllCall("GlobalLock", Ptr, hData, Ptr)
    DllCall("RtlMoveMemory", Ptr, pData, Ptr, &BRAFromMemIn+Info2+FileInfo1, Ptr, FileInfo2)
    DllCall("GlobalUnlock", Ptr, hData)
    DllCall("ole32\CreateStreamOnHGlobal", Ptr, hData, "int", 1, A_PtrSize ? "UPtr*" : "UInt*", pStream)
    DllCall("gdiplus\GdipCreateBitmapFromStream", Ptr, pStream, A_PtrSize ? "UPtr*" : "UInt*", pBitmap)
    If (A_PtrSize)
        %FName%(pStream)
    Else
        DllCall(NumGet(NumGet(1*pStream)+8), "uint", pStream)
    return pBitmap
}

;#####################################################################################

; Function              Gdip_DrawRectangle
; Description           This function uses a pen to draw the outline of a rectangle into the Graphics of a bitmap
;
; pGraphics             Pointer to the Graphics of a bitmap
; pPen                  Pointer to a pen
; x                     x-coordinate of the top left of the rectangle
; y                     y-coordinate of the top left of the rectangle
; w                     width of the rectanlge
; h                     height of the rectangle
;
; return                status enumeration. 0 = success
;
; notes                 as all coordinates are taken from the top left of each pixel, then the entire width/height should be specified as subtracting the pen width

Gdip_DrawRectangle(pGraphics, pPen, x, y, w, h)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    return DllCall("gdiplus\GdipDrawRectangle", Ptr, pGraphics, Ptr, pPen, "float", x, "float", y, "float", w, "float", h)
}

;#####################################################################################

; Function              Gdip_DrawRoundedRectangle
; Description           This function uses a pen to draw the outline of a rounded rectangle into the Graphics of a bitmap
;
; pGraphics             Pointer to the Graphics of a bitmap
; pPen                  Pointer to a pen
; x                     x-coordinate of the top left of the rounded rectangle
; y                     y-coordinate of the top left of the rounded rectangle
; w                     width of the rectanlge
; h                     height of the rectangle
; r                     radius of the rounded corners
;
; return                status enumeration. 0 = success
;
; notes                 as all coordinates are taken from the top left of each pixel, then the entire width/height should be specified as subtracting the pen width

Gdip_DrawRoundedRectangle(pGraphics, pPen, x, y, w, h, r)
{
    Gdip_SetClipRect(pGraphics, x-r, y-r, 2*r, 2*r, 4)
    Gdip_SetClipRect(pGraphics, x+w-r, y-r, 2*r, 2*r, 4)
    Gdip_SetClipRect(pGraphics, x-r, y+h-r, 2*r, 2*r, 4)
    Gdip_SetClipRect(pGraphics, x+w-r, y+h-r, 2*r, 2*r, 4)
    E := Gdip_DrawRectangle(pGraphics, pPen, x, y, w, h)
    Gdip_ResetClip(pGraphics)
    Gdip_SetClipRect(pGraphics, x-(2*r), y+r, w+(4*r), h-(2*r), 4)
    Gdip_SetClipRect(pGraphics, x+r, y-(2*r), w-(2*r), h+(4*r), 4)
    Gdip_DrawEllipse(pGraphics, pPen, x, y, 2*r, 2*r)
    Gdip_DrawEllipse(pGraphics, pPen, x+w-(2*r), y, 2*r, 2*r)
    Gdip_DrawEllipse(pGraphics, pPen, x, y+h-(2*r), 2*r, 2*r)
    Gdip_DrawEllipse(pGraphics, pPen, x+w-(2*r), y+h-(2*r), 2*r, 2*r)
    Gdip_ResetClip(pGraphics)
    return E
}

;#####################################################################################

; Function              Gdip_DrawEllipse
; Description           This function uses a pen to draw the outline of an ellipse into the Graphics of a bitmap
;
; pGraphics             Pointer to the Graphics of a bitmap
; pPen                  Pointer to a pen
; x                     x-coordinate of the top left of the rectangle the ellipse will be drawn into
; y                     y-coordinate of the top left of the rectangle the ellipse will be drawn into
; w                     width of the ellipse
; h                     height of the ellipse
;
; return                status enumeration. 0 = success
;
; notes                 as all coordinates are taken from the top left of each pixel, then the entire width/height should be specified as subtracting the pen width

Gdip_DrawEllipse(pGraphics, pPen, x, y, w, h)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    return DllCall("gdiplus\GdipDrawEllipse", Ptr, pGraphics, Ptr, pPen, "float", x, "float", y, "float", w, "float", h)
}

;#####################################################################################

; Function              Gdip_DrawBezier
; Description           This function uses a pen to draw the outline of a bezier (a weighted curve) into the Graphics of a bitmap
;
; pGraphics             Pointer to the Graphics of a bitmap
; pPen                  Pointer to a pen
; x1                    x-coordinate of the start of the bezier
; y1                    y-coordinate of the start of the bezier
; x2                    x-coordinate of the first arc of the bezier
; y2                    y-coordinate of the first arc of the bezier
; x3                    x-coordinate of the second arc of the bezier
; y3                    y-coordinate of the second arc of the bezier
; x4                    x-coordinate of the end of the bezier
; y4                    y-coordinate of the end of the bezier
;
; return                status enumeration. 0 = success
;
; notes                 as all coordinates are taken from the top left of each pixel, then the entire width/height should be specified as subtracting the pen width

Gdip_DrawBezier(pGraphics, pPen, x1, y1, x2, y2, x3, y3, x4, y4)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    return DllCall("gdiplus\GdipDrawBezier"
                    , Ptr, pgraphics
                    , Ptr, pPen
                    , "float", x1
                    , "float", y1
                    , "float", x2
                    , "float", y2
                    , "float", x3
                    , "float", y3
                    , "float", x4
                    , "float", y4)
}

;#####################################################################################

; Function              Gdip_DrawArc
; Description           This function uses a pen to draw the outline of an arc into the Graphics of a bitmap
;
; pGraphics             Pointer to the Graphics of a bitmap
; pPen                  Pointer to a pen
; x                     x-coordinate of the start of the arc
; y                     y-coordinate of the start of the arc
; w                     width of the arc
; h                     height of the arc
; StartAngle            specifies the angle between the x-axis and the starting point of the arc
; SweepAngle            specifies the angle between the starting and ending points of the arc
;
; return                status enumeration. 0 = success
;
; notes                 as all coordinates are taken from the top left of each pixel, then the entire width/height should be specified as subtracting the pen width

Gdip_DrawArc(pGraphics, pPen, x, y, w, h, StartAngle, SweepAngle)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    return DllCall("gdiplus\GdipDrawArc"
                    , Ptr, pGraphics
                    , Ptr, pPen
                    , "float", x
                    , "float", y
                    , "float", w
                    , "float", h
                    , "float", StartAngle
                    , "float", SweepAngle)
}

;#####################################################################################

; Function              Gdip_DrawPie
; Description           This function uses a pen to draw the outline of a pie into the Graphics of a bitmap
;
; pGraphics             Pointer to the Graphics of a bitmap
; pPen                  Pointer to a pen
; x                     x-coordinate of the start of the pie
; y                     y-coordinate of the start of the pie
; w                     width of the pie
; h                     height of the pie
; StartAngle            specifies the angle between the x-axis and the starting point of the pie
; SweepAngle            specifies the angle between the starting and ending points of the pie
;
; return                status enumeration. 0 = success
;
; notes                 as all coordinates are taken from the top left of each pixel, then the entire width/height should be specified as subtracting the pen width

Gdip_DrawPie(pGraphics, pPen, x, y, w, h, StartAngle, SweepAngle)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    return DllCall("gdiplus\GdipDrawPie", Ptr, pGraphics, Ptr, pPen, "float", x, "float", y, "float", w, "float", h, "float", StartAngle, "float", SweepAngle)
}

;#####################################################################################

; Function              Gdip_DrawLine
; Description           This function uses a pen to draw a line into the Graphics of a bitmap
;
; pGraphics             Pointer to the Graphics of a bitmap
; pPen                  Pointer to a pen
; x1                    x-coordinate of the start of the line
; y1                    y-coordinate of the start of the line
; x2                    x-coordinate of the end of the line
; y2                    y-coordinate of the end of the line
;
; return                status enumeration. 0 = success

Gdip_DrawLine(pGraphics, pPen, x1, y1, x2, y2)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    return DllCall("gdiplus\GdipDrawLine"
                    , Ptr, pGraphics
                    , Ptr, pPen
                    , "float", x1
                    , "float", y1
                    , "float", x2
                    , "float", y2)
}

;#####################################################################################

; Function              Gdip_DrawLines
; Description           This function uses a pen to draw a series of joined lines into the Graphics of a bitmap
;
; pGraphics             Pointer to the Graphics of a bitmap
; pPen                  Pointer to a pen
; Points                the coordinates of all the points passed as x1,y1|x2,y2|x3,y3.....
;
; return                status enumeration. 0 = success

Gdip_DrawLines(pGraphics, pPen, Points)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"
    StringSplit, Points, Points, |
    VarSetCapacity(PointF, 8*Points0)
    Loop, %Points0%
    {
        StringSplit, Coord, Points%A_Index%, `,
        NumPut(Coord1, PointF, 8*(A_Index-1), "float"), NumPut(Coord2, PointF, (8*(A_Index-1))+4, "float")
    }
    return DllCall("gdiplus\GdipDrawLines", Ptr, pGraphics, Ptr, pPen, Ptr, &PointF, "int", Points0)
}

;#####################################################################################

; Function              Gdip_FillRectangle
; Description           This function uses a brush to fill a rectangle in the Graphics of a bitmap
;
; pGraphics             Pointer to the Graphics of a bitmap
; pBrush                Pointer to a brush
; x                     x-coordinate of the top left of the rectangle
; y                     y-coordinate of the top left of the rectangle
; w                     width of the rectanlge
; h                     height of the rectangle
;
; return                status enumeration. 0 = success

Gdip_FillRectangle(pGraphics, pBrush, x, y, w, h)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    return DllCall("gdiplus\GdipFillRectangle"
                    , Ptr, pGraphics
                    , Ptr, pBrush
                    , "float", x
                    , "float", y
                    , "float", w
                    , "float", h)
}

;#####################################################################################

; Function              Gdip_FillRoundedRectangle
; Description           This function uses a brush to fill a rounded rectangle in the Graphics of a bitmap
;
; pGraphics             Pointer to the Graphics of a bitmap
; pBrush                Pointer to a brush
; x                     x-coordinate of the top left of the rounded rectangle
; y                     y-coordinate of the top left of the rounded rectangle
; w                     width of the rectanlge
; h                     height of the rectangle
; r                     radius of the rounded corners
;
; return                status enumeration. 0 = success

Gdip_FillRoundedRectangle(pGraphics, pBrush, x, y, w, h, r)
{
    Region := Gdip_GetClipRegion(pGraphics)
    Gdip_SetClipRect(pGraphics, x-r, y-r, 2*r, 2*r, 4)
    Gdip_SetClipRect(pGraphics, x+w-r, y-r, 2*r, 2*r, 4)
    Gdip_SetClipRect(pGraphics, x-r, y+h-r, 2*r, 2*r, 4)
    Gdip_SetClipRect(pGraphics, x+w-r, y+h-r, 2*r, 2*r, 4)
    E := Gdip_FillRectangle(pGraphics, pBrush, x, y, w, h)
    Gdip_SetClipRegion(pGraphics, Region, 0)
    Gdip_SetClipRect(pGraphics, x-(2*r), y+r, w+(4*r), h-(2*r), 4)
    Gdip_SetClipRect(pGraphics, x+r, y-(2*r), w-(2*r), h+(4*r), 4)
    Gdip_FillEllipse(pGraphics, pBrush, x, y, 2*r, 2*r)
    Gdip_FillEllipse(pGraphics, pBrush, x+w-(2*r), y, 2*r, 2*r)
    Gdip_FillEllipse(pGraphics, pBrush, x, y+h-(2*r), 2*r, 2*r)
    Gdip_FillEllipse(pGraphics, pBrush, x+w-(2*r), y+h-(2*r), 2*r, 2*r)
    Gdip_SetClipRegion(pGraphics, Region, 0)
    Gdip_DeleteRegion(Region)
    return E
}

;#####################################################################################

; Function              Gdip_FillPolygon
; Description           This function uses a brush to fill a polygon in the Graphics of a bitmap
;
; pGraphics             Pointer to the Graphics of a bitmap
; pBrush                Pointer to a brush
; Points                the coordinates of all the points passed as x1,y1|x2,y2|x3,y3.....
;
; return                status enumeration. 0 = success
;
; notes                 Alternate will fill the polygon as a whole, wheras winding will fill each new "segment"
; Alternate             = 0
; Winding               = 1

Gdip_FillPolygon(pGraphics, pBrush, Points, FillMode=0)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    StringSplit, Points, Points, |
    VarSetCapacity(PointF, 8*Points0)
    Loop, %Points0%
    {
        StringSplit, Coord, Points%A_Index%, `,
        NumPut(Coord1, PointF, 8*(A_Index-1), "float"), NumPut(Coord2, PointF, (8*(A_Index-1))+4, "float")
    }
    return DllCall("gdiplus\GdipFillPolygon", Ptr, pGraphics, Ptr, pBrush, Ptr, &PointF, "int", Points0, "int", FillMode)
}

;#####################################################################################

; Function              Gdip_FillPie
; Description           This function uses a brush to fill a pie in the Graphics of a bitmap
;
; pGraphics             Pointer to the Graphics of a bitmap
; pBrush                Pointer to a brush
; x                     x-coordinate of the top left of the pie
; y                     y-coordinate of the top left of the pie
; w                     width of the pie
; h                     height of the pie
; StartAngle            specifies the angle between the x-axis and the starting point of the pie
; SweepAngle            specifies the angle between the starting and ending points of the pie
;
; return                status enumeration. 0 = success

Gdip_FillPie(pGraphics, pBrush, x, y, w, h, StartAngle, SweepAngle)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    return DllCall("gdiplus\GdipFillPie"
                    , Ptr, pGraphics
                    , Ptr, pBrush
                    , "float", x
                    , "float", y
                    , "float", w
                    , "float", h
                    , "float", StartAngle
                    , "float", SweepAngle)
}

;#####################################################################################

; Function              Gdip_FillEllipse
; Description           This function uses a brush to fill an ellipse in the Graphics of a bitmap
;
; pGraphics             Pointer to the Graphics of a bitmap
; pBrush                Pointer to a brush
; x                     x-coordinate of the top left of the ellipse
; y                     y-coordinate of the top left of the ellipse
; w                     width of the ellipse
; h                     height of the ellipse
;
; return                status enumeration. 0 = success

Gdip_FillEllipse(pGraphics, pBrush, x, y, w, h)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    return DllCall("gdiplus\GdipFillEllipse", Ptr, pGraphics, Ptr, pBrush, "float", x, "float", y, "float", w, "float", h)
}

;#####################################################################################

; Function              Gdip_FillRegion
; Description           This function uses a brush to fill a region in the Graphics of a bitmap
;
; pGraphics             Pointer to the Graphics of a bitmap
; pBrush                Pointer to a brush
; Region                Pointer to a Region
;
; return                status enumeration. 0 = success
;
; notes                 You can create a region Gdip_CreateRegion() and then add to this

Gdip_FillRegion(pGraphics, pBrush, Region)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    return DllCall("gdiplus\GdipFillRegion", Ptr, pGraphics, Ptr, pBrush, Ptr, Region)
}

;#####################################################################################

; Function              Gdip_FillPath
; Description           This function uses a brush to fill a path in the Graphics of a bitmap
;
; pGraphics             Pointer to the Graphics of a bitmap
; pBrush                Pointer to a brush
; Region                Pointer to a Path
;
; return                status enumeration. 0 = success

Gdip_FillPath(pGraphics, pBrush, Path)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    return DllCall("gdiplus\GdipFillPath", Ptr, pGraphics, Ptr, pBrush, Ptr, Path)
}

;#####################################################################################

; Function              Gdip_DrawImagePointsRect
; Description           This function draws a bitmap into the Graphics of another bitmap and skews it
;
; pGraphics             Pointer to the Graphics of a bitmap
; pBitmap               Pointer to a bitmap to be drawn
; Points                Points passed as x1,y1|x2,y2|x3,y3 (3 points: top left, top right, bottom left) describing the drawing of the bitmap
; sx                    x-coordinate of source upper-left corner
; sy                    y-coordinate of source upper-left corner
; sw                    width of source rectangle
; sh                    height of source rectangle
; Matrix                a matrix used to alter image attributes when drawing
;
; return                status enumeration. 0 = success
;
; notes                 if sx,sy,sw,sh are missed then the entire source bitmap will be used
;                       Matrix can be omitted to just draw with no alteration to ARGB
;                       Matrix may be passed as a digit from 0 - 1 to change just transparency
;                       Matrix can be passed as a matrix with any delimiter

Gdip_DrawImagePointsRect(pGraphics, pBitmap, Points, sx="", sy="", sw="", sh="", Matrix=1)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    StringSplit, Points, Points, |
    VarSetCapacity(PointF, 8*Points0)
    Loop, %Points0%
    {
        StringSplit, Coord, Points%A_Index%, `,
        NumPut(Coord1, PointF, 8*(A_Index-1), "float"), NumPut(Coord2, PointF, (8*(A_Index-1))+4, "float")
    }

    if (Matrix&1 = "")
        ImageAttr := Gdip_SetImageAttributesColorMatrix(Matrix)
    else if (Matrix != 1)
        ImageAttr := Gdip_SetImageAttributesColorMatrix("1|0|0|0|0|0|1|0|0|0|0|0|1|0|0|0|0|0|" Matrix "|0|0|0|0|0|1")

    if (sx = "" && sy = "" && sw = "" && sh = "")
    {
        sx := 0, sy := 0
        sw := Gdip_GetImageWidth(pBitmap)
        sh := Gdip_GetImageHeight(pBitmap)
    }

    E := DllCall("gdiplus\GdipDrawImagePointsRect"
                , Ptr, pGraphics
                , Ptr, pBitmap
                , Ptr, &PointF
                , "int", Points0
                , "float", sx
                , "float", sy
                , "float", sw
                , "float", sh
                , "int", 2
                , Ptr, ImageAttr
                , Ptr, 0
                , Ptr, 0)
    if ImageAttr
        Gdip_DisposeImageAttributes(ImageAttr)
    return E
}

;#####################################################################################

; Function              Gdip_DrawImage
; Description           This function draws a bitmap into the Graphics of another bitmap
;
; pGraphics             Pointer to the Graphics of a bitmap
; pBitmap               Pointer to a bitmap to be drawn
; dx                    x-coord of destination upper-left corner
; dy                    y-coord of destination upper-left corner
; dw                    width of destination image
; dh                    height of destination image
; sx                    x-coordinate of source upper-left corner
; sy                    y-coordinate of source upper-left corner
; sw                    width of source image
; sh                    height of source image
; Matrix                a matrix used to alter image attributes when drawing
;
; return                status enumeration. 0 = success
;
; notes                 if sx,sy,sw,sh are missed then the entire source bitmap will be used
;                       Gdip_DrawImage performs faster
;                       Matrix can be omitted to just draw with no alteration to ARGB
;                       Matrix may be passed as a digit from 0 - 1 to change just transparency
;                       Matrix can be passed as a matrix with any delimiter. For example:
;                       MatrixBright=
;                       (
;                       1.5     |0      |0      |0      |0
;                       0       |1.5    |0      |0      |0
;                       0       |0      |1.5    |0      |0
;                       0       |0      |0      |1      |0
;                       0.05    |0.05   |0.05   |0      |1
;                       )
;
; notes                 MatrixBright = 1.5|0|0|0|0|0|1.5|0|0|0|0|0|1.5|0|0|0|0|0|1|0|0.05|0.05|0.05|0|1
;                       MatrixGreyScale = 0.299|0.299|0.299|0|0|0.587|0.587|0.587|0|0|0.114|0.114|0.114|0|0|0|0|0|1|0|0|0|0|0|1
;                       MatrixNegative = -1|0|0|0|0|0|-1|0|0|0|0|0|-1|0|0|0|0|0|1|0|0|0|0|0|1

Gdip_DrawImage(pGraphics, pBitmap, dx="", dy="", dw="", dh="", sx="", sy="", sw="", sh="", Matrix=1)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    if (Matrix&1 = "")
        ImageAttr := Gdip_SetImageAttributesColorMatrix(Matrix)
    else if (Matrix != 1)
        ImageAttr := Gdip_SetImageAttributesColorMatrix("1|0|0|0|0|0|1|0|0|0|0|0|1|0|0|0|0|0|" Matrix "|0|0|0|0|0|1")

    if (sx = "" && sy = "" && sw = "" && sh = "")
    {
        if (dx = "" && dy = "" && dw = "" && dh = "")
        {
            sx := dx := 0, sy := dy := 0
            sw := dw := Gdip_GetImageWidth(pBitmap)
            sh := dh := Gdip_GetImageHeight(pBitmap)
        }
        else
        {
            sx := sy := 0
            sw := Gdip_GetImageWidth(pBitmap)
            sh := Gdip_GetImageHeight(pBitmap)
        }
    }

    E := DllCall("gdiplus\GdipDrawImageRectRect"
                , Ptr, pGraphics
                , Ptr, pBitmap
                , "float", dx
                , "float", dy
                , "float", dw
                , "float", dh
                , "float", sx
                , "float", sy
                , "float", sw
                , "float", sh
                , "int", 2
                , Ptr, ImageAttr
                , Ptr, 0
                , Ptr, 0)
    if ImageAttr
        Gdip_DisposeImageAttributes(ImageAttr)
    return E
}

;#####################################################################################

; Function              Gdip_SetImageAttributesColorMatrix
; Description           This function creates an image matrix ready for drawing
;
; Matrix                a matrix used to alter image attributes when drawing
;                       passed with any delimeter
;
; return                returns an image matrix on sucess or 0 if it fails
;
; notes                 MatrixBright = 1.5|0|0|0|0|0|1.5|0|0|0|0|0|1.5|0|0|0|0|0|1|0|0.05|0.05|0.05|0|1
;                       MatrixGreyScale = 0.299|0.299|0.299|0|0|0.587|0.587|0.587|0|0|0.114|0.114|0.114|0|0|0|0|0|1|0|0|0|0|0|1
;                       MatrixNegative = -1|0|0|0|0|0|-1|0|0|0|0|0|-1|0|0|0|0|0|1|0|0|0|0|0|1

Gdip_SetImageAttributesColorMatrix(Matrix)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    VarSetCapacity(ColourMatrix, 100, 0)
    Matrix := RegExReplace(RegExReplace(Matrix, "^[^\d-\.]+([\d\.])", "$1", "", 1), "[^\d-\.]+", "|")
    StringSplit, Matrix, Matrix, |
    Loop, 25
    {
        Matrix := (Matrix%A_Index% != "") ? Matrix%A_Index% : Mod(A_Index-1, 6) ? 0 : 1
        NumPut(Matrix, ColourMatrix, (A_Index-1)*4, "float")
    }
    DllCall("gdiplus\GdipCreateImageAttributes", A_PtrSize ? "UPtr*" : "uint*", ImageAttr)
    DllCall("gdiplus\GdipSetImageAttributesColorMatrix", Ptr, ImageAttr, "int", 1, "int", 1, Ptr, &ColourMatrix, Ptr, 0, "int", 0)
    return ImageAttr
}

;#####################################################################################

; Function              Gdip_GraphicsFromImage
; Description           This function gets the graphics for a bitmap used for drawing functions
;
; pBitmap               Pointer to a bitmap to get the pointer to its graphics
;
; return                returns a pointer to the graphics of a bitmap
;
; notes                 a bitmap can be drawn into the graphics of another bitmap

Gdip_GraphicsFromImage(pBitmap)
{
    DllCall("gdiplus\GdipGetImageGraphicsContext", A_PtrSize ? "UPtr" : "UInt", pBitmap, A_PtrSize ? "UPtr*" : "UInt*", pGraphics)
    return pGraphics
}

;#####################################################################################

; Function              Gdip_GraphicsFromHDC
; Description           This function gets the graphics from the handle to a device context
;
; hdc                   This is the handle to the device context
;
; return                returns a pointer to the graphics of a bitmap
;
; notes                 You can draw a bitmap into the graphics of another bitmap

Gdip_GraphicsFromHDC(hdc)
{
    DllCall("gdiplus\GdipCreateFromHDC", A_PtrSize ? "UPtr" : "UInt", hdc, A_PtrSize ? "UPtr*" : "UInt*", pGraphics)
    return pGraphics
}

;#####################################################################################

; Function              Gdip_GetDC
; Description           This function gets the device context of the passed Graphics
;
; hdc                   This is the handle to the device context
;
; return                returns the device context for the graphics of a bitmap

Gdip_GetDC(pGraphics)
{
    DllCall("gdiplus\GdipGetDC", A_PtrSize ? "UPtr" : "UInt", pGraphics, A_PtrSize ? "UPtr*" : "UInt*", hdc)
    return hdc
}

;#####################################################################################

; Function              Gdip_ReleaseDC
; Description           This function releases a device context from use for further use
;
; pGraphics             Pointer to the graphics of a bitmap
; hdc                   This is the handle to the device context
;
; return                status enumeration. 0 = success

Gdip_ReleaseDC(pGraphics, hdc)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    return DllCall("gdiplus\GdipReleaseDC", Ptr, pGraphics, Ptr, hdc)
}

;#####################################################################################

; Function              Gdip_GraphicsClear
; Description           Clears the graphics of a bitmap ready for further drawing
;
; pGraphics             Pointer to the graphics of a bitmap
; ARGB                  The colour to clear the graphics to
;
; return                status enumeration. 0 = success
;
; notes                 By default this will make the background invisible
;                       Using clipping regions you can clear a particular area on the graphics rather than clearing the entire graphics

Gdip_GraphicsClear(pGraphics, ARGB=0x00ffffff)
{
    return DllCall("gdiplus\GdipGraphicsClear", A_PtrSize ? "UPtr" : "UInt", pGraphics, "int", ARGB)
}

;#####################################################################################

; Function              Gdip_BlurBitmap
; Description           Gives a pointer to a blurred bitmap from a pointer to a bitmap
;
; pBitmap               Pointer to a bitmap to be blurred
; Blur                  The Amount to blur a bitmap by from 1 (least blur) to 100 (most blur)
;
; return                If the function succeeds, the return value is a pointer to the new blurred bitmap
;                       -1 = The blur parameter is outside the range 1-100
;
; notes                 This function will not dispose of the original bitmap

Gdip_BlurBitmap(pBitmap, Blur)
{
    if (Blur > 100) || (Blur < 1)
        return -1

    sWidth := Gdip_GetImageWidth(pBitmap), sHeight := Gdip_GetImageHeight(pBitmap)
    dWidth := sWidth//Blur, dHeight := sHeight//Blur

    pBitmap1 := Gdip_CreateBitmap(dWidth, dHeight)
    G1 := Gdip_GraphicsFromImage(pBitmap1)
    Gdip_SetInterpolationMode(G1, 7)
    Gdip_DrawImage(G1, pBitmap, 0, 0, dWidth, dHeight, 0, 0, sWidth, sHeight)

    Gdip_DeleteGraphics(G1)

    pBitmap2 := Gdip_CreateBitmap(sWidth, sHeight)
    G2 := Gdip_GraphicsFromImage(pBitmap2)
    Gdip_SetInterpolationMode(G2, 7)
    Gdip_DrawImage(G2, pBitmap1, 0, 0, sWidth, sHeight, 0, 0, dWidth, dHeight)

    Gdip_DeleteGraphics(G2)
    Gdip_DisposeImage(pBitmap1)
    return pBitmap2
}

;#####################################################################################

; Function:             Gdip_SaveBitmapToFile
; Description:          Saves a bitmap to a file in any supported format onto disk
;
; pBitmap               Pointer to a bitmap
; sOutput               The name of the file that the bitmap will be saved to. Supported extensions are: .BMP,.DIB,.RLE,.JPG,.JPEG,.JPE,.JFIF,.GIF,.TIF,.TIFF,.PNG
; Quality               If saving as jpg (.JPG,.JPEG,.JPE,.JFIF) then quality can be 1-100 with default at maximum quality
;
; return                If the function succeeds, the return value is zero, otherwise:
;                       -1 = Extension supplied is not a supported file format
;                       -2 = Could not get a list of encoders on system
;                       -3 = Could not find matching encoder for specified file format
;                       -4 = Could not get WideChar name of output file
;                       -5 = Could not save file to disk
;
; notes                 This function will use the extension supplied from the sOutput parameter to determine the output format

Gdip_SaveBitmapToFile(pBitmap, sOutput, Quality=75)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    SplitPath, sOutput,,, Extension
    if Extension not in BMP,DIB,RLE,JPG,JPEG,JPE,JFIF,GIF,TIF,TIFF,PNG
        return -1
    Extension := "." Extension

    DllCall("gdiplus\GdipGetImageEncodersSize", "uint*", nCount, "uint*", nSize)
    VarSetCapacity(ci, nSize)
    DllCall("gdiplus\GdipGetImageEncoders", "uint", nCount, "uint", nSize, Ptr, &ci)
    if !(nCount && nSize)
        return -2

    If (A_IsUnicode){
        StrGet_Name := "StrGet"
        Loop, %nCount%
        {
            sString := %StrGet_Name%(NumGet(ci, (idx := (48+7*A_PtrSize)*(A_Index-1))+32+3*A_PtrSize), "UTF-16")
            if !InStr(sString, "*" Extension)
                continue

            pCodec := &ci+idx
            break
        }
    } else {
        Loop, %nCount%
        {
            Location := NumGet(ci, 76*(A_Index-1)+44)
            nSize := DllCall("WideCharToMultiByte", "uint", 0, "uint", 0, "uint", Location, "int", -1, "uint", 0, "int",  0, "uint", 0, "uint", 0)
            VarSetCapacity(sString, nSize)
            DllCall("WideCharToMultiByte", "uint", 0, "uint", 0, "uint", Location, "int", -1, "str", sString, "int", nSize, "uint", 0, "uint", 0)
            if !InStr(sString, "*" Extension)
                continue

            pCodec := &ci+76*(A_Index-1)
            break
        }
    }

    if !pCodec
        return -3

    if (Quality != 75)
    {
        Quality := (Quality < 0) ? 0 : (Quality > 100) ? 100 : Quality
        if Extension in .JPG,.JPEG,.JPE,.JFIF
        {
            DllCall("gdiplus\GdipGetEncoderParameterListSize", Ptr, pBitmap, Ptr, pCodec, "uint*", nSize)
            VarSetCapacity(EncoderParameters, nSize, 0)
            DllCall("gdiplus\GdipGetEncoderParameterList", Ptr, pBitmap, Ptr, pCodec, "uint", nSize, Ptr, &EncoderParameters)
            Loop, % NumGet(EncoderParameters, "UInt")      ;%
            {
                elem := (24+(A_PtrSize ? A_PtrSize : 4))*(A_Index-1) + 4 + (pad := A_PtrSize = 8 ? 4 : 0)
                if (NumGet(EncoderParameters, elem+16, "UInt") = 1) && (NumGet(EncoderParameters, elem+20, "UInt") = 6)
                {
                    p := elem+&EncoderParameters-pad-4
                    NumPut(Quality, NumGet(NumPut(4, NumPut(1, p+0)+20, "UInt")), "UInt")
                    break
                }
            }
        }
    }

    if (!A_IsUnicode)
    {
        nSize := DllCall("MultiByteToWideChar", "uint", 0, "uint", 0, Ptr, &sOutput, "int", -1, Ptr, 0, "int", 0)
        VarSetCapacity(wOutput, nSize*2)
        DllCall("MultiByteToWideChar", "uint", 0, "uint", 0, Ptr, &sOutput, "int", -1, Ptr, &wOutput, "int", nSize)
        VarSetCapacity(wOutput, -1)
        if !VarSetCapacity(wOutput)
            return -4
        E := DllCall("gdiplus\GdipSaveImageToFile", Ptr, pBitmap, Ptr, &wOutput, Ptr, pCodec, "uint", p ? p : 0)
    }
    else
        E := DllCall("gdiplus\GdipSaveImageToFile", Ptr, pBitmap, Ptr, &sOutput, Ptr, pCodec, "uint", p ? p : 0)
    return E ? -5 : 0
}

;#####################################################################################

; Function              Gdip_GetPixel
; Description           Gets the ARGB of a pixel in a bitmap
;
; pBitmap               Pointer to a bitmap
; x                     x-coordinate of the pixel
; y                     y-coordinate of the pixel
;
; return                Returns the ARGB value of the pixel

Gdip_GetPixel(pBitmap, x, y)
{
    DllCall("gdiplus\GdipBitmapGetPixel", A_PtrSize ? "UPtr" : "UInt", pBitmap, "int", x, "int", y, "uint*", ARGB)
    return ARGB
}

;#####################################################################################

; Function              Gdip_SetPixel
; Description           Sets the ARGB of a pixel in a bitmap
;
; pBitmap               Pointer to a bitmap
; x                     x-coordinate of the pixel
; y                     y-coordinate of the pixel
;
; return                status enumeration. 0 = success

Gdip_SetPixel(pBitmap, x, y, ARGB)
{
   return DllCall("gdiplus\GdipBitmapSetPixel", A_PtrSize ? "UPtr" : "UInt", pBitmap, "int", x, "int", y, "int", ARGB)
}

;#####################################################################################

; Function              Gdip_GetImageWidth
; Description           Gives the width of a bitmap
;
; pBitmap               Pointer to a bitmap
;
; return                Returns the width in pixels of the supplied bitmap

Gdip_GetImageWidth(pBitmap)
{
   DllCall("gdiplus\GdipGetImageWidth", A_PtrSize ? "UPtr" : "UInt", pBitmap, "uint*", Width)
   return Width
}

;#####################################################################################

; Function              Gdip_GetImageHeight
; Description           Gives the height of a bitmap
;
; pBitmap               Pointer to a bitmap
;
; return                Returns the height in pixels of the supplied bitmap

Gdip_GetImageHeight(pBitmap)
{
   DllCall("gdiplus\GdipGetImageHeight", A_PtrSize ? "UPtr" : "UInt", pBitmap, "uint*", Height)
   return Height
}

;#####################################################################################

; Function              Gdip_GetDimensions
; Description           Gives the width and height of a bitmap
;
; pBitmap               Pointer to a bitmap
; Width                 ByRef variable. This variable will be set to the width of the bitmap
; Height                ByRef variable. This variable will be set to the height of the bitmap
;
; return                No return value
;                       Gdip_GetDimensions(pBitmap, ThisWidth, ThisHeight) will set ThisWidth to the width and ThisHeight to the height

Gdip_GetImageDimensions(pBitmap, ByRef Width, ByRef Height)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"
    DllCall("gdiplus\GdipGetImageWidth", Ptr, pBitmap, "uint*", Width)
    DllCall("gdiplus\GdipGetImageHeight", Ptr, pBitmap, "uint*", Height)
}

;#####################################################################################

Gdip_GetDimensions(pBitmap, ByRef Width, ByRef Height)
{
    Gdip_GetImageDimensions(pBitmap, Width, Height)
}

;#####################################################################################

Gdip_GetImagePixelFormat(pBitmap)
{
    DllCall("gdiplus\GdipGetImagePixelFormat", A_PtrSize ? "UPtr" : "UInt", pBitmap, A_PtrSize ? "UPtr*" : "UInt*", Format)
    return Format
}

;#####################################################################################

; Function              Gdip_GetDpiX
; Description           Gives the horizontal dots per inch of the graphics of a bitmap
;
; pBitmap               Pointer to a bitmap
; Width                 ByRef variable. This variable will be set to the width of the bitmap
; Height                ByRef variable. This variable will be set to the height of the bitmap
;
; return                No return value
;                       Gdip_GetDimensions(pBitmap, ThisWidth, ThisHeight) will set ThisWidth to the width and ThisHeight to the height

Gdip_GetDpiX(pGraphics)
{
    DllCall("gdiplus\GdipGetDpiX", A_PtrSize ? "UPtr" : "uint", pGraphics, "float*", dpix)
    return Round(dpix)
}

;#####################################################################################

Gdip_GetDpiY(pGraphics)
{
    DllCall("gdiplus\GdipGetDpiY", A_PtrSize ? "UPtr" : "uint", pGraphics, "float*", dpiy)
    return Round(dpiy)
}

;#####################################################################################

Gdip_GetImageHorizontalResolution(pBitmap)
{
    DllCall("gdiplus\GdipGetImageHorizontalResolution", A_PtrSize ? "UPtr" : "uint", pBitmap, "float*", dpix)
    return Round(dpix)
}

;#####################################################################################

Gdip_GetImageVerticalResolution(pBitmap)
{
    DllCall("gdiplus\GdipGetImageVerticalResolution", A_PtrSize ? "UPtr" : "uint", pBitmap, "float*", dpiy)
    return Round(dpiy)
}

;#####################################################################################

Gdip_BitmapSetResolution(pBitmap, dpix, dpiy)
{
    return DllCall("gdiplus\GdipBitmapSetResolution", A_PtrSize ? "UPtr" : "uint", pBitmap, "float", dpix, "float", dpiy)
}

;#####################################################################################

Gdip_CreateBitmapFromFile(sFile, IconNumber=1, IconSize="")
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"
    , PtrA := A_PtrSize ? "UPtr*" : "UInt*"

    SplitPath, sFile,,, ext
    if ext in exe,dll
    {
        Sizes := IconSize ? IconSize : 256 "|" 128 "|" 64 "|" 48 "|" 32 "|" 16
        BufSize := 16 + (2*(A_PtrSize ? A_PtrSize : 4))

        VarSetCapacity(buf, BufSize, 0)
        Loop, Parse, Sizes, |
        {
            DllCall("PrivateExtractIcons", "str", sFile, "int", IconNumber-1, "int", A_LoopField, "int", A_LoopField, PtrA, hIcon, PtrA, 0, "uint", 1, "uint", 0)

            if !hIcon
                continue

            if !DllCall("GetIconInfo", Ptr, hIcon, Ptr, &buf)
            {
                DestroyIcon(hIcon)
                continue
            }

            hbmMask  := NumGet(buf, 12 + ((A_PtrSize ? A_PtrSize : 4) - 4))
            hbmColor := NumGet(buf, 12 + ((A_PtrSize ? A_PtrSize : 4) - 4) + (A_PtrSize ? A_PtrSize : 4))
            if !(hbmColor && DllCall("GetObject", Ptr, hbmColor, "int", BufSize, Ptr, &buf))
            {
                DestroyIcon(hIcon)
                continue
            }
            break
        }
        if !hIcon
            return -1

        Width := NumGet(buf, 4, "int"), Height := NumGet(buf, 8, "int")
        hbm := CreateDIBSection(Width, -Height), hdc := CreateCompatibleDC(), obm := SelectObject(hdc, hbm)
        if !DllCall("DrawIconEx", Ptr, hdc, "int", 0, "int", 0, Ptr, hIcon, "uint", Width, "uint", Height, "uint", 0, Ptr, 0, "uint", 3)
        {
            DestroyIcon(hIcon)
            return -2
        }

        VarSetCapacity(dib, 104)
        DllCall("GetObject", Ptr, hbm, "int", A_PtrSize = 8 ? 104 : 84, Ptr, &dib) ; sizeof(DIBSECTION) = 76+2*(A_PtrSize=8?4:0)+2*A_PtrSize
        Stride := NumGet(dib, 12, "Int"), Bits := NumGet(dib, 20 + (A_PtrSize = 8 ? 4 : 0)) ; padding
        DllCall("gdiplus\GdipCreateBitmapFromScan0", "int", Width, "int", Height, "int", Stride, "int", 0x26200A, Ptr, Bits, PtrA, pBitmapOld)
        pBitmap := Gdip_CreateBitmap(Width, Height)
        G := Gdip_GraphicsFromImage(pBitmap)
        , Gdip_DrawImage(G, pBitmapOld, 0, 0, Width, Height, 0, 0, Width, Height)
        SelectObject(hdc, obm), DeleteObject(hbm), DeleteDC(hdc)
        Gdip_DeleteGraphics(G), Gdip_DisposeImage(pBitmapOld)
        DestroyIcon(hIcon)
    }
    else
    {
        if (!A_IsUnicode)
        {
            VarSetCapacity(wFile, 1024)
            DllCall("kernel32\MultiByteToWideChar", "uint", 0, "uint", 0, Ptr, &sFile, "int", -1, Ptr, &wFile, "int", 512)
            DllCall("gdiplus\GdipCreateBitmapFromFile", Ptr, &wFile, PtrA, pBitmap)
        }
        else
            DllCall("gdiplus\GdipCreateBitmapFromFile", Ptr, &sFile, PtrA, pBitmap)
    }

    return pBitmap
}

;#####################################################################################

Gdip_CreateBitmapFromHBITMAP(hBitmap, Palette=0)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    DllCall("gdiplus\GdipCreateBitmapFromHBITMAP", Ptr, hBitmap, Ptr, Palette, A_PtrSize ? "UPtr*" : "uint*", pBitmap)
    return pBitmap
}

;#####################################################################################

Gdip_CreateHBITMAPFromBitmap(pBitmap, Background=0xffffffff)
{
    DllCall("gdiplus\GdipCreateHBITMAPFromBitmap", A_PtrSize ? "UPtr" : "UInt", pBitmap, A_PtrSize ? "UPtr*" : "uint*", hbm, "int", Background)
    return hbm
}

;#####################################################################################

Gdip_CreateBitmapFromHICON(hIcon)
{
    DllCall("gdiplus\GdipCreateBitmapFromHICON", A_PtrSize ? "UPtr" : "UInt", hIcon, A_PtrSize ? "UPtr*" : "uint*", pBitmap)
    return pBitmap
}

;#####################################################################################

Gdip_CreateHICONFromBitmap(pBitmap)
{
    DllCall("gdiplus\GdipCreateHICONFromBitmap", A_PtrSize ? "UPtr" : "UInt", pBitmap, A_PtrSize ? "UPtr*" : "uint*", hIcon)
    return hIcon
}

;#####################################################################################

Gdip_CreateBitmap(Width, Height, Format=0x26200A)
{
    DllCall("gdiplus\GdipCreateBitmapFromScan0", "int", Width, "int", Height, "int", 0, "int", Format, A_PtrSize ? "UPtr" : "UInt", 0, A_PtrSize ? "UPtr*" : "uint*", pBitmap)
    Return pBitmap
}

;#####################################################################################

Gdip_CreateBitmapFromClipboard()
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    if !DllCall("OpenClipboard", Ptr, 0)
        return -1
    if !DllCall("IsClipboardFormatAvailable", "uint", 8)
        return -2
    if !hBitmap := DllCall("GetClipboardData", "uint", 2, Ptr)
        return -3
    if !pBitmap := Gdip_CreateBitmapFromHBITMAP(hBitmap)
        return -4
    if !DllCall("CloseClipboard")
        return -5
    DeleteObject(hBitmap)
    return pBitmap
}

;#####################################################################################

Gdip_SetBitmapToClipboard(pBitmap)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"
    off1 := A_PtrSize = 8 ? 52 : 44, off2 := A_PtrSize = 8 ? 32 : 24
    hBitmap := Gdip_CreateHBITMAPFromBitmap(pBitmap)
    DllCall("GetObject", Ptr, hBitmap, "int", VarSetCapacity(oi, A_PtrSize = 8 ? 104 : 84, 0), Ptr, &oi)
    hdib := DllCall("GlobalAlloc", "uint", 2, Ptr, 40+NumGet(oi, off1, "UInt"), Ptr)
    pdib := DllCall("GlobalLock", Ptr, hdib, Ptr)
    DllCall("RtlMoveMemory", Ptr, pdib, Ptr, &oi+off2, Ptr, 40)
    DllCall("RtlMoveMemory", Ptr, pdib+40, Ptr, NumGet(oi, off2 - (A_PtrSize ? A_PtrSize : 4), Ptr), Ptr, NumGet(oi, off1, "UInt"))
    DllCall("GlobalUnlock", Ptr, hdib)
    DllCall("DeleteObject", Ptr, hBitmap)
    DllCall("OpenClipboard", Ptr, 0)
    DllCall("EmptyClipboard")
    DllCall("SetClipboardData", "uint", 8, Ptr, hdib)
    DllCall("CloseClipboard")
}

;#####################################################################################

Gdip_CloneBitmapArea(pBitmap, x, y, w, h, Format=0x26200A)
{
    DllCall("gdiplus\GdipCloneBitmapArea"
                    , "float", x
                    , "float", y
                    , "float", w
                    , "float", h
                    , "int", Format
                    , A_PtrSize ? "UPtr" : "UInt", pBitmap
                    , A_PtrSize ? "UPtr*" : "UInt*", pBitmapDest)
    return pBitmapDest
}

;#####################################################################################
; Create resources
;#####################################################################################

Gdip_CreatePen(ARGB, w)
{
   DllCall("gdiplus\GdipCreatePen1", "UInt", ARGB, "float", w, "int", 2, A_PtrSize ? "UPtr*" : "UInt*", pPen)
   return pPen
}

;#####################################################################################

Gdip_CreatePenFromBrush(pBrush, w)
{
    DllCall("gdiplus\GdipCreatePen2", A_PtrSize ? "UPtr" : "UInt", pBrush, "float", w, "int", 2, A_PtrSize ? "UPtr*" : "UInt*", pPen)
    return pPen
}

;#####################################################################################

Gdip_BrushCreateSolid(ARGB=0xff000000)
{
    DllCall("gdiplus\GdipCreateSolidFill", "UInt", ARGB, A_PtrSize ? "UPtr*" : "UInt*", pBrush)
    return pBrush
}

;#####################################################################################

; HatchStyleHorizontal = 0
; HatchStyleVertical = 1
; HatchStyleForwardDiagonal = 2
; HatchStyleBackwardDiagonal = 3
; HatchStyleCross = 4
; HatchStyleDiagonalCross = 5
; HatchStyle05Percent = 6
; HatchStyle10Percent = 7
; HatchStyle20Percent = 8
; HatchStyle25Percent = 9
; HatchStyle30Percent = 10
; HatchStyle40Percent = 11
; HatchStyle50Percent = 12
; HatchStyle60Percent = 13
; HatchStyle70Percent = 14
; HatchStyle75Percent = 15
; HatchStyle80Percent = 16
; HatchStyle90Percent = 17
; HatchStyleLightDownwardDiagonal = 18
; HatchStyleLightUpwardDiagonal = 19
; HatchStyleDarkDownwardDiagonal = 20
; HatchStyleDarkUpwardDiagonal = 21
; HatchStyleWideDownwardDiagonal = 22
; HatchStyleWideUpwardDiagonal = 23
; HatchStyleLightVertical = 24
; HatchStyleLightHorizontal = 25
; HatchStyleNarrowVertical = 26
; HatchStyleNarrowHorizontal = 27
; HatchStyleDarkVertical = 28
; HatchStyleDarkHorizontal = 29
; HatchStyleDashedDownwardDiagonal = 30
; HatchStyleDashedUpwardDiagonal = 31
; HatchStyleDashedHorizontal = 32
; HatchStyleDashedVertical = 33
; HatchStyleSmallConfetti = 34
; HatchStyleLargeConfetti = 35
; HatchStyleZigZag = 36
; HatchStyleWave = 37
; HatchStyleDiagonalBrick = 38
; HatchStyleHorizontalBrick = 39
; HatchStyleWeave = 40
; HatchStylePlaid = 41
; HatchStyleDivot = 42
; HatchStyleDottedGrid = 43
; HatchStyleDottedDiamond = 44
; HatchStyleShingle = 45
; HatchStyleTrellis = 46
; HatchStyleSphere = 47
; HatchStyleSmallGrid = 48
; HatchStyleSmallCheckerBoard = 49
; HatchStyleLargeCheckerBoard = 50
; HatchStyleOutlinedDiamond = 51
; HatchStyleSolidDiamond = 52
; HatchStyleTotal = 53
Gdip_BrushCreateHatch(ARGBfront, ARGBback, HatchStyle=0)
{
    DllCall("gdiplus\GdipCreateHatchBrush", "int", HatchStyle, "UInt", ARGBfront, "UInt", ARGBback, A_PtrSize ? "UPtr*" : "UInt*", pBrush)
    return pBrush
}

;#####################################################################################

Gdip_CreateTextureBrush(pBitmap, WrapMode=1, x=0, y=0, w="", h="")
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"
    , PtrA := A_PtrSize ? "UPtr*" : "UInt*"

    if !(w && h)
        DllCall("gdiplus\GdipCreateTexture", Ptr, pBitmap, "int", WrapMode, PtrA, pBrush)
    else
        DllCall("gdiplus\GdipCreateTexture2", Ptr, pBitmap, "int", WrapMode, "float", x, "float", y, "float", w, "float", h, PtrA, pBrush)
    return pBrush
}

;#####################################################################################

; WrapModeTile = 0
; WrapModeTileFlipX = 1
; WrapModeTileFlipY = 2
; WrapModeTileFlipXY = 3
; WrapModeClamp = 4
Gdip_CreateLineBrush(x1, y1, x2, y2, ARGB1, ARGB2, WrapMode=1)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    CreatePointF(PointF1, x1, y1), CreatePointF(PointF2, x2, y2)
    DllCall("gdiplus\GdipCreateLineBrush", Ptr, &PointF1, Ptr, &PointF2, "Uint", ARGB1, "Uint", ARGB2, "int", WrapMode, A_PtrSize ? "UPtr*" : "UInt*", LGpBrush)
    return LGpBrush
}

;#####################################################################################

; LinearGradientModeHorizontal = 0
; LinearGradientModeVertical = 1
; LinearGradientModeForwardDiagonal = 2
; LinearGradientModeBackwardDiagonal = 3
Gdip_CreateLineBrushFromRect(x, y, w, h, ARGB1, ARGB2, LinearGradientMode=1, WrapMode=1)
{
    CreateRectF(RectF, x, y, w, h)
    DllCall("gdiplus\GdipCreateLineBrushFromRect", A_PtrSize ? "UPtr" : "UInt", &RectF, "int", ARGB1, "int", ARGB2, "int", LinearGradientMode, "int", WrapMode, A_PtrSize ? "UPtr*" : "UInt*", LGpBrush)
    return LGpBrush
}

;#####################################################################################

Gdip_CloneBrush(pBrush)
{
    DllCall("gdiplus\GdipCloneBrush", A_PtrSize ? "UPtr" : "UInt", pBrush, A_PtrSize ? "UPtr*" : "UInt*", pBrushClone)
    return pBrushClone
}

;#####################################################################################
; Delete resources
;#####################################################################################

Gdip_DeletePen(pPen)
{
   return DllCall("gdiplus\GdipDeletePen", A_PtrSize ? "UPtr" : "UInt", pPen)
}

;#####################################################################################

Gdip_DeleteBrush(pBrush)
{
   return DllCall("gdiplus\GdipDeleteBrush", A_PtrSize ? "UPtr" : "UInt", pBrush)
}

;#####################################################################################

Gdip_DisposeImage(pBitmap)
{
   return DllCall("gdiplus\GdipDisposeImage", A_PtrSize ? "UPtr" : "UInt", pBitmap)
}

;#####################################################################################

Gdip_DeleteGraphics(pGraphics)
{
   return DllCall("gdiplus\GdipDeleteGraphics", A_PtrSize ? "UPtr" : "UInt", pGraphics)
}

;#####################################################################################

Gdip_DisposeImageAttributes(ImageAttr)
{
    return DllCall("gdiplus\GdipDisposeImageAttributes", A_PtrSize ? "UPtr" : "UInt", ImageAttr)
}

;#####################################################################################

Gdip_DeleteFont(hFont)
{
   return DllCall("gdiplus\GdipDeleteFont", A_PtrSize ? "UPtr" : "UInt", hFont)
}

;#####################################################################################

Gdip_DeleteStringFormat(hFormat)
{
   return DllCall("gdiplus\GdipDeleteStringFormat", A_PtrSize ? "UPtr" : "UInt", hFormat)
}

;#####################################################################################

Gdip_DeleteFontFamily(hFamily)
{
   return DllCall("gdiplus\GdipDeleteFontFamily", A_PtrSize ? "UPtr" : "UInt", hFamily)
}

;#####################################################################################

Gdip_DeleteMatrix(Matrix)
{
   return DllCall("gdiplus\GdipDeleteMatrix", A_PtrSize ? "UPtr" : "UInt", Matrix)
}

;#####################################################################################
; Text functions
;#####################################################################################

Gdip_TextToGraphics(pGraphics, Text, Options, Font="Arial", Width="", Height="", Measure=0)
{
    IWidth := Width, IHeight:= Height

    RegExMatch(Options, "i)X([\-\d\.]+)(p*)", xpos)
    RegExMatch(Options, "i)Y([\-\d\.]+)(p*)", ypos)
    RegExMatch(Options, "i)W([\-\d\.]+)(p*)", Width)
    RegExMatch(Options, "i)H([\-\d\.]+)(p*)", Height)
    RegExMatch(Options, "i)C(?!(entre|enter))([a-f\d]+)", Colour)
    RegExMatch(Options, "i)Top|Up|Bottom|Down|vCentre|vCenter", vPos)
    RegExMatch(Options, "i)NoWrap", NoWrap)
    RegExMatch(Options, "i)R(\d)", Rendering)
    RegExMatch(Options, "i)S(\d+)(p*)", Size)

    if !Gdip_DeleteBrush(Gdip_CloneBrush(Colour2))
        PassBrush := 1, pBrush := Colour2

    if !(IWidth && IHeight) && (xpos2 || ypos2 || Width2 || Height2 || Size2)
        return -1

    Style := 0, Styles := "Regular|Bold|Italic|BoldItalic|Underline|Strikeout"
    Loop, Parse, Styles, |
    {
        if RegExMatch(Options, "\b" A_loopField)
        Style |= (A_LoopField != "StrikeOut") ? (A_Index-1) : 8
    }

    Align := 0, Alignments := "Near|Left|Centre|Center|Far|Right"
    Loop, Parse, Alignments, |
    {
        if RegExMatch(Options, "\b" A_loopField)
            Align |= A_Index//2.1      ; 0|0|1|1|2|2
    }

    xpos := (xpos1 != "") ? xpos2 ? IWidth*(xpos1/100) : xpos1 : 0
    ypos := (ypos1 != "") ? ypos2 ? IHeight*(ypos1/100) : ypos1 : 0
    Width := Width1 ? Width2 ? IWidth*(Width1/100) : Width1 : IWidth
    Height := Height1 ? Height2 ? IHeight*(Height1/100) : Height1 : IHeight
    if !PassBrush
        Colour := "0x" (Colour2 ? Colour2 : "ff000000")
    Rendering := ((Rendering1 >= 0) && (Rendering1 <= 5)) ? Rendering1 : 4
    Size := (Size1 > 0) ? Size2 ? IHeight*(Size1/100) : Size1 : 12

    hFamily := Gdip_FontFamilyCreate(Font)
    hFont := Gdip_FontCreate(hFamily, Size, Style)
    FormatStyle := NoWrap ? 0x4000 | 0x1000 : 0x4000
    hFormat := Gdip_StringFormatCreate(FormatStyle)
    pBrush := PassBrush ? pBrush : Gdip_BrushCreateSolid(Colour)
    if !(hFamily && hFont && hFormat && pBrush && pGraphics)
        return !pGraphics ? -2 : !hFamily ? -3 : !hFont ? -4 : !hFormat ? -5 : !pBrush ? -6 : 0

    CreateRectF(RC, xpos, ypos, Width, Height)
    Gdip_SetStringFormatAlign(hFormat, Align)
    Gdip_SetTextRenderingHint(pGraphics, Rendering)
    ReturnRC := Gdip_MeasureString(pGraphics, Text, hFont, hFormat, RC)

    if vPos
    {
        StringSplit, ReturnRC, ReturnRC, |

        if (vPos = "vCentre") || (vPos = "vCenter")
            ypos += (Height-ReturnRC4)//2
        else if (vPos = "Top") || (vPos = "Up")
            ypos := 0
        else if (vPos = "Bottom") || (vPos = "Down")
            ypos := Height-ReturnRC4

        CreateRectF(RC, xpos, ypos, Width, ReturnRC4)
        ReturnRC := Gdip_MeasureString(pGraphics, Text, hFont, hFormat, RC)
    }

    if !Measure
        E := Gdip_DrawString(pGraphics, Text, hFont, hFormat, pBrush, RC)

    if !PassBrush
        Gdip_DeleteBrush(pBrush)
    Gdip_DeleteStringFormat(hFormat)
    Gdip_DeleteFont(hFont)
    Gdip_DeleteFontFamily(hFamily)
    return E ? E : ReturnRC
}

;#####################################################################################

Gdip_DrawString(pGraphics, sString, hFont, hFormat, pBrush, ByRef RectF)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    if (!A_IsUnicode)
    {
        nSize := DllCall("MultiByteToWideChar", "uint", 0, "uint", 0, Ptr, &sString, "int", -1, Ptr, 0, "int", 0)
        VarSetCapacity(wString, nSize*2)
        DllCall("MultiByteToWideChar", "uint", 0, "uint", 0, Ptr, &sString, "int", -1, Ptr, &wString, "int", nSize)
    }

    return DllCall("gdiplus\GdipDrawString"
                    , Ptr, pGraphics
                    , Ptr, A_IsUnicode ? &sString : &wString
                    , "int", -1
                    , Ptr, hFont
                    , Ptr, &RectF
                    , Ptr, hFormat
                    , Ptr, pBrush)
}

;#####################################################################################

Gdip_MeasureString(pGraphics, sString, hFont, hFormat, ByRef RectF)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    VarSetCapacity(RC, 16)
    if !A_IsUnicode
    {
        nSize := DllCall("MultiByteToWideChar", "uint", 0, "uint", 0, Ptr, &sString, "int", -1, "uint", 0, "int", 0)
        VarSetCapacity(wString, nSize*2)
        DllCall("MultiByteToWideChar", "uint", 0, "uint", 0, Ptr, &sString, "int", -1, Ptr, &wString, "int", nSize)
    }

    DllCall("gdiplus\GdipMeasureString"
                    , Ptr, pGraphics
                    , Ptr, A_IsUnicode ? &sString : &wString
                    , "int", -1
                    , Ptr, hFont
                    , Ptr, &RectF
                    , Ptr, hFormat
                    , Ptr, &RC
                    , "uint*", Chars
                    , "uint*", Lines)

    return &RC ? NumGet(RC, 0, "float") "|" NumGet(RC, 4, "float") "|" NumGet(RC, 8, "float") "|" NumGet(RC, 12, "float") "|" Chars "|" Lines : 0
}

; Near = 0
; Center = 1
; Far = 2
Gdip_SetStringFormatAlign(hFormat, Align)
{
   return DllCall("gdiplus\GdipSetStringFormatAlign", A_PtrSize ? "UPtr" : "UInt", hFormat, "int", Align)
}

; StringFormatFlagsDirectionRightToLeft    = 0x00000001
; StringFormatFlagsDirectionVertical       = 0x00000002
; StringFormatFlagsNoFitBlackBox           = 0x00000004
; StringFormatFlagsDisplayFormatControl    = 0x00000020
; StringFormatFlagsNoFontFallback          = 0x00000400
; StringFormatFlagsMeasureTrailingSpaces   = 0x00000800
; StringFormatFlagsNoWrap                  = 0x00001000
; StringFormatFlagsLineLimit               = 0x00002000
; StringFormatFlagsNoClip                  = 0x00004000
Gdip_StringFormatCreate(Format=0, Lang=0)
{
   DllCall("gdiplus\GdipCreateStringFormat", "int", Format, "int", Lang, A_PtrSize ? "UPtr*" : "UInt*", hFormat)
   return hFormat
}

; Regular = 0
; Bold = 1
; Italic = 2
; BoldItalic = 3
; Underline = 4
; Strikeout = 8
Gdip_FontCreate(hFamily, Size, Style=0)
{
   DllCall("gdiplus\GdipCreateFont", A_PtrSize ? "UPtr" : "UInt", hFamily, "float", Size, "int", Style, "int", 0, A_PtrSize ? "UPtr*" : "UInt*", hFont)
   return hFont
}

Gdip_FontFamilyCreate(Font)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    if (!A_IsUnicode)
    {
        nSize := DllCall("MultiByteToWideChar", "uint", 0, "uint", 0, Ptr, &Font, "int", -1, "uint", 0, "int", 0)
        VarSetCapacity(wFont, nSize*2)
        DllCall("MultiByteToWideChar", "uint", 0, "uint", 0, Ptr, &Font, "int", -1, Ptr, &wFont, "int", nSize)
    }

    DllCall("gdiplus\GdipCreateFontFamilyFromName"
                    , Ptr, A_IsUnicode ? &Font : &wFont
                    , "uint", 0
                    , A_PtrSize ? "UPtr*" : "UInt*", hFamily)

    return hFamily
}

;#####################################################################################
; Matrix functions
;#####################################################################################

Gdip_CreateAffineMatrix(m11, m12, m21, m22, x, y)
{
   DllCall("gdiplus\GdipCreateMatrix2", "float", m11, "float", m12, "float", m21, "float", m22, "float", x, "float", y, A_PtrSize ? "UPtr*" : "UInt*", Matrix)
   return Matrix
}

Gdip_CreateMatrix()
{
   DllCall("gdiplus\GdipCreateMatrix", A_PtrSize ? "UPtr*" : "UInt*", Matrix)
   return Matrix
}

;#####################################################################################
; GraphicsPath functions
;#####################################################################################

; Alternate = 0
; Winding = 1
Gdip_CreatePath(BrushMode=0)
{
    DllCall("gdiplus\GdipCreatePath", "int", BrushMode, A_PtrSize ? "UPtr*" : "UInt*", Path)
    return Path
}

Gdip_AddPathEllipse(Path, x, y, w, h)
{
    return DllCall("gdiplus\GdipAddPathEllipse", A_PtrSize ? "UPtr" : "UInt", Path, "float", x, "float", y, "float", w, "float", h)
}

Gdip_AddPathPolygon(Path, Points)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    StringSplit, Points, Points, |
    VarSetCapacity(PointF, 8*Points0)
    Loop, %Points0%
    {
        StringSplit, Coord, Points%A_Index%, `,
        NumPut(Coord1, PointF, 8*(A_Index-1), "float"), NumPut(Coord2, PointF, (8*(A_Index-1))+4, "float")
    }

    return DllCall("gdiplus\GdipAddPathPolygon", Ptr, Path, Ptr, &PointF, "int", Points0)
}

Gdip_DeletePath(Path)
{
    return DllCall("gdiplus\GdipDeletePath", A_PtrSize ? "UPtr" : "UInt", Path)
}

;#####################################################################################
; Quality functions
;#####################################################################################

; SystemDefault = 0
; SingleBitPerPixelGridFit = 1
; SingleBitPerPixel = 2
; AntiAliasGridFit = 3
; AntiAlias = 4
Gdip_SetTextRenderingHint(pGraphics, RenderingHint)
{
    return DllCall("gdiplus\GdipSetTextRenderingHint", A_PtrSize ? "UPtr" : "UInt", pGraphics, "int", RenderingHint)
}

; Default = 0
; LowQuality = 1
; HighQuality = 2
; Bilinear = 3
; Bicubic = 4
; NearestNeighbor = 5
; HighQualityBilinear = 6
; HighQualityBicubic = 7
Gdip_SetInterpolationMode(pGraphics, InterpolationMode)
{
   return DllCall("gdiplus\GdipSetInterpolationMode", A_PtrSize ? "UPtr" : "UInt", pGraphics, "int", InterpolationMode)
}

; Default = 0
; HighSpeed = 1
; HighQuality = 2
; None = 3
; AntiAlias = 4
Gdip_SetSmoothingMode(pGraphics, SmoothingMode)
{
   return DllCall("gdiplus\GdipSetSmoothingMode", A_PtrSize ? "UPtr" : "UInt", pGraphics, "int", SmoothingMode)
}

; CompositingModeSourceOver = 0 (blended)
; CompositingModeSourceCopy = 1 (overwrite)
Gdip_SetCompositingMode(pGraphics, CompositingMode=0)
{
   return DllCall("gdiplus\GdipSetCompositingMode", A_PtrSize ? "UPtr" : "UInt", pGraphics, "int", CompositingMode)
}

;#####################################################################################
; Extra functions
;#####################################################################################

Gdip_Startup()
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    if !DllCall("GetModuleHandle", "str", "gdiplus", Ptr)
        DllCall("LoadLibrary", "str", "gdiplus")
    VarSetCapacity(si, A_PtrSize = 8 ? 24 : 16, 0), si := Chr(1)
    DllCall("gdiplus\GdiplusStartup", A_PtrSize ? "UPtr*" : "uint*", pToken, Ptr, &si, Ptr, 0)
    return pToken
}

Gdip_Shutdown(pToken)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    DllCall("gdiplus\GdiplusShutdown", Ptr, pToken)
    if hModule := DllCall("GetModuleHandle", "str", "gdiplus", Ptr)
        DllCall("FreeLibrary", Ptr, hModule)
    return 0
}

; Prepend = 0; The new operation is applied before the old operation.
; Append = 1; The new operation is applied after the old operation.
Gdip_RotateWorldTransform(pGraphics, Angle, MatrixOrder=0)
{
    return DllCall("gdiplus\GdipRotateWorldTransform", A_PtrSize ? "UPtr" : "UInt", pGraphics, "float", Angle, "int", MatrixOrder)
}

Gdip_ScaleWorldTransform(pGraphics, x, y, MatrixOrder=0)
{
    return DllCall("gdiplus\GdipScaleWorldTransform", A_PtrSize ? "UPtr" : "UInt", pGraphics, "float", x, "float", y, "int", MatrixOrder)
}

Gdip_TranslateWorldTransform(pGraphics, x, y, MatrixOrder=0)
{
    return DllCall("gdiplus\GdipTranslateWorldTransform", A_PtrSize ? "UPtr" : "UInt", pGraphics, "float", x, "float", y, "int", MatrixOrder)
}

Gdip_ResetWorldTransform(pGraphics)
{
    return DllCall("gdiplus\GdipResetWorldTransform", A_PtrSize ? "UPtr" : "UInt", pGraphics)
}

Gdip_GetRotatedTranslation(Width, Height, Angle, ByRef xTranslation, ByRef yTranslation)
{
    pi := 3.14159, TAngle := Angle*(pi/180)

    Bound := (Angle >= 0) ? Mod(Angle, 360) : 360-Mod(-Angle, -360)
    if ((Bound >= 0) && (Bound <= 90))
        xTranslation := Height*Sin(TAngle), yTranslation := 0
    else if ((Bound > 90) && (Bound <= 180))
        xTranslation := (Height*Sin(TAngle))-(Width*Cos(TAngle)), yTranslation := -Height*Cos(TAngle)
    else if ((Bound > 180) && (Bound <= 270))
        xTranslation := -(Width*Cos(TAngle)), yTranslation := -(Height*Cos(TAngle))-(Width*Sin(TAngle))
    else if ((Bound > 270) && (Bound <= 360))
        xTranslation := 0, yTranslation := -Width*Sin(TAngle)
}

Gdip_GetRotatedDimensions(Width, Height, Angle, ByRef RWidth, ByRef RHeight)
{
    pi := 3.14159, TAngle := Angle*(pi/180)
    if !(Width && Height)
        return -1
    RWidth := Ceil(Abs(Width*Cos(TAngle))+Abs(Height*Sin(TAngle)))
    RHeight := Ceil(Abs(Width*Sin(TAngle))+Abs(Height*Cos(Tangle)))
}

; RotateNoneFlipNone   = 0
; Rotate90FlipNone     = 1
; Rotate180FlipNone    = 2
; Rotate270FlipNone    = 3
; RotateNoneFlipX      = 4
; Rotate90FlipX        = 5
; Rotate180FlipX       = 6
; Rotate270FlipX       = 7
; RotateNoneFlipY      = Rotate180FlipX
; Rotate90FlipY        = Rotate270FlipX
; Rotate180FlipY       = RotateNoneFlipX
; Rotate270FlipY       = Rotate90FlipX
; RotateNoneFlipXY     = Rotate180FlipNone
; Rotate90FlipXY       = Rotate270FlipNone
; Rotate180FlipXY      = RotateNoneFlipNone
; Rotate270FlipXY      = Rotate90FlipNone

Gdip_ImageRotateFlip(pBitmap, RotateFlipType=1)
{
    return DllCall("gdiplus\GdipImageRotateFlip", A_PtrSize ? "UPtr" : "UInt", pBitmap, "int", RotateFlipType)
}

; Replace = 0
; Intersect = 1
; Union = 2
; Xor = 3
; Exclude = 4
; Complement = 5
Gdip_SetClipRect(pGraphics, x, y, w, h, CombineMode=0)
{
   return DllCall("gdiplus\GdipSetClipRect",  A_PtrSize ? "UPtr" : "UInt", pGraphics, "float", x, "float", y, "float", w, "float", h, "int", CombineMode)
}

Gdip_SetClipPath(pGraphics, Path, CombineMode=0)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"
    return DllCall("gdiplus\GdipSetClipPath", Ptr, pGraphics, Ptr, Path, "int", CombineMode)
}

Gdip_ResetClip(pGraphics)
{
   return DllCall("gdiplus\GdipResetClip", A_PtrSize ? "UPtr" : "UInt", pGraphics)
}

Gdip_GetClipRegion(pGraphics)
{
    Region := Gdip_CreateRegion()
    DllCall("gdiplus\GdipGetClip", A_PtrSize ? "UPtr" : "UInt", pGraphics, "UInt*", Region)
    return Region
}

Gdip_SetClipRegion(pGraphics, Region, CombineMode=0)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    return DllCall("gdiplus\GdipSetClipRegion", Ptr, pGraphics, Ptr, Region, "int", CombineMode)
}

Gdip_CreateRegion()
{
    DllCall("gdiplus\GdipCreateRegion", "UInt*", Region)
    return Region
}

Gdip_DeleteRegion(Region)
{
    return DllCall("gdiplus\GdipDeleteRegion", A_PtrSize ? "UPtr" : "UInt", Region)
}

;#####################################################################################
; BitmapLockBits
;#####################################################################################

Gdip_LockBits(pBitmap, x, y, w, h, ByRef Stride, ByRef Scan0, ByRef BitmapData, LockMode = 3, PixelFormat = 0x26200a)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    CreateRect(Rect, x, y, w, h)
    VarSetCapacity(BitmapData, 16+2*(A_PtrSize ? A_PtrSize : 4), 0)
    E := DllCall("Gdiplus\GdipBitmapLockBits", Ptr, pBitmap, Ptr, &Rect, "uint", LockMode, "int", PixelFormat, Ptr, &BitmapData)
    Stride := NumGet(BitmapData, 8, "Int")
    Scan0 := NumGet(BitmapData, 16, Ptr)
    return E
}

;#####################################################################################

Gdip_UnlockBits(pBitmap, ByRef BitmapData)
{
    Ptr := A_PtrSize ? "UPtr" : "UInt"

    return DllCall("Gdiplus\GdipBitmapUnlockBits", Ptr, pBitmap, Ptr, &BitmapData)
}

;#####################################################################################

Gdip_SetLockBitPixel(ARGB, Scan0, x, y, Stride)
{
    Numput(ARGB, Scan0+0, (x*4)+(y*Stride), "UInt")
}

;#####################################################################################

Gdip_GetLockBitPixel(Scan0, x, y, Stride)
{
    return NumGet(Scan0+0, (x*4)+(y*Stride), "UInt")
}

;#####################################################################################

Gdip_PixelateBitmap(pBitmap, ByRef pBitmapOut, BlockSize)
{
    static PixelateBitmap

    Ptr := A_PtrSize ? "UPtr" : "UInt"

    if (!PixelateBitmap)
    {
        if A_PtrSize != 8 ; x86 machine code
        MCode_PixelateBitmap =
        (LTrim Join
        558BEC83EC3C8B4514538B5D1C99F7FB56578BC88955EC894DD885C90F8E830200008B451099F7FB8365DC008365E000894DC88955F08945E833FF897DD4
        397DE80F8E160100008BCB0FAFCB894DCC33C08945F88945FC89451C8945143BD87E608B45088D50028BC82BCA8BF02BF2418945F48B45E02955F4894DC4
        8D0CB80FAFCB03CA895DD08BD1895DE40FB64416030145140FB60201451C8B45C40FB604100145FC8B45F40FB604020145F883C204FF4DE475D6034D18FF
        4DD075C98B4DCC8B451499F7F98945148B451C99F7F989451C8B45FC99F7F98945FC8B45F899F7F98945F885DB7E648B450C8D50028BC82BCA83C103894D
        C48BC82BCA41894DF48B4DD48945E48B45E02955E48D0C880FAFCB03CA895DD08BD18BF38A45148B7DC48804178A451C8B7DF488028A45FC8804178A45F8
        8B7DE488043A83C2044E75DA034D18FF4DD075CE8B4DCC8B7DD447897DD43B7DE80F8CF2FEFFFF837DF0000F842C01000033C08945F88945FC89451C8945
        148945E43BD87E65837DF0007E578B4DDC034DE48B75E80FAF4D180FAFF38B45088D500203CA8D0CB18BF08BF88945F48B45F02BF22BFA2955F48945CC0F
        B6440E030145140FB60101451C0FB6440F010145FC8B45F40FB604010145F883C104FF4DCC75D8FF45E4395DE47C9B8B4DF00FAFCB85C9740B8B451499F7
        F9894514EB048365140033F63BCE740B8B451C99F7F989451CEB0389751C3BCE740B8B45FC99F7F98945FCEB038975FC3BCE740B8B45F899F7F98945F8EB
        038975F88975E43BDE7E5A837DF0007E4C8B4DDC034DE48B75E80FAF4D180FAFF38B450C8D500203CA8D0CB18BF08BF82BF22BFA2BC28B55F08955CC8A55
        1488540E038A551C88118A55FC88540F018A55F888140183C104FF4DCC75DFFF45E4395DE47CA68B45180145E0015DDCFF4DC80F8594FDFFFF8B451099F7
        FB8955F08945E885C00F8E450100008B45EC0FAFC38365DC008945D48B45E88945CC33C08945F88945FC89451C8945148945103945EC7E6085DB7E518B4D
        D88B45080FAFCB034D108D50020FAF4D18034DDC8BF08BF88945F403CA2BF22BFA2955F4895DC80FB6440E030145140FB60101451C0FB6440F010145FC8B
        45F40FB604080145F883C104FF4DC875D8FF45108B45103B45EC7CA08B4DD485C9740B8B451499F7F9894514EB048365140033F63BCE740B8B451C99F7F9
        89451CEB0389751C3BCE740B8B45FC99F7F98945FCEB038975FC3BCE740B8B45F899F7F98945F8EB038975F88975103975EC7E5585DB7E468B4DD88B450C
        0FAFCB034D108D50020FAF4D18034DDC8BF08BF803CA2BF22BFA2BC2895DC88A551488540E038A551C88118A55FC88540F018A55F888140183C104FF4DC8
        75DFFF45108B45103B45EC7CAB8BC3C1E0020145DCFF4DCC0F85CEFEFFFF8B4DEC33C08945F88945FC89451C8945148945103BC87E6C3945F07E5C8B4DD8
        8B75E80FAFCB034D100FAFF30FAF4D188B45088D500203CA8D0CB18BF08BF88945F48B45F02BF22BFA2955F48945C80FB6440E030145140FB60101451C0F
        B6440F010145FC8B45F40FB604010145F883C104FF4DC875D833C0FF45108B4DEC394D107C940FAF4DF03BC874068B451499F7F933F68945143BCE740B8B
        451C99F7F989451CEB0389751C3BCE740B8B45FC99F7F98945FCEB038975FC3BCE740B8B45F899F7F98945F8EB038975F88975083975EC7E63EB0233F639
        75F07E4F8B4DD88B75E80FAFCB034D080FAFF30FAF4D188B450C8D500203CA8D0CB18BF08BF82BF22BFA2BC28B55F08955108A551488540E038A551C8811
        8A55FC88540F018A55F888140883C104FF4D1075DFFF45088B45083B45EC7C9F5F5E33C05BC9C21800
        )
        else ; x64 machine code
        MCode_PixelateBitmap =
        (LTrim Join
        4489442418488954241048894C24085355565741544155415641574883EC28418BC1448B8C24980000004C8BDA99488BD941F7F9448BD0448BFA8954240C
        448994248800000085C00F8E9D020000418BC04533E4458BF299448924244C8954241041F7F933C9898C24980000008BEA89542404448BE889442408EB05
        4C8B5C24784585ED0F8E1A010000458BF1418BFD48897C2418450FAFF14533D233F633ED4533E44533ED4585C97E5B4C63BC2490000000418D040A410FAF
        C148984C8D441802498BD9498BD04D8BD90FB642010FB64AFF4403E80FB60203E90FB64AFE4883C2044403E003F149FFCB75DE4D03C748FFCB75D0488B7C
        24188B8C24980000004C8B5C2478418BC59941F7FE448BE8418BC49941F7FE448BE08BC59941F7FE8BE88BC69941F7FE8BF04585C97E4048639C24900000
        004103CA4D8BC1410FAFC94863C94A8D541902488BCA498BC144886901448821408869FF408871FE4883C10448FFC875E84803D349FFC875DA8B8C249800
        0000488B5C24704C8B5C24784183C20448FFCF48897C24180F850AFFFFFF8B6C2404448B2424448B6C24084C8B74241085ED0F840A01000033FF33DB4533
        DB4533D24533C04585C97E53488B74247085ED7E42438D0C04418BC50FAF8C2490000000410FAFC18D04814863C8488D5431028BCD0FB642014403D00FB6
        024883C2044403D80FB642FB03D80FB642FA03F848FFC975DE41FFC0453BC17CB28BCD410FAFC985C9740A418BC299F7F98BF0EB0233F685C9740B418BC3
        99F7F9448BD8EB034533DB85C9740A8BC399F7F9448BD0EB034533D285C9740A8BC799F7F9448BC0EB034533C033D24585C97E4D4C8B74247885ED7E3841
        8D0C14418BC50FAF8C2490000000410FAFC18D04814863C84A8D4431028BCD40887001448818448850FF448840FE4883C00448FFC975E8FFC2413BD17CBD
        4C8B7424108B8C2498000000038C2490000000488B5C24704503E149FFCE44892424898C24980000004C897424100F859EFDFFFF448B7C240C448B842480
        000000418BC09941F7F98BE8448BEA89942498000000896C240C85C00F8E3B010000448BAC2488000000418BCF448BF5410FAFC9898C248000000033FF33
        ED33F64533DB4533D24533C04585FF7E524585C97E40418BC5410FAFC14103C00FAF84249000000003C74898488D541802498BD90FB642014403D00FB602
        4883C2044403D80FB642FB03F00FB642FA03E848FFCB75DE488B5C247041FFC0453BC77CAE85C9740B418BC299F7F9448BE0EB034533E485C9740A418BC3
        99F7F98BD8EB0233DB85C9740A8BC699F7F9448BD8EB034533DB85C9740A8BC599F7F9448BD0EB034533D24533C04585FF7E4E488B4C24784585C97E3541
        8BC5410FAFC14103C00FAF84249000000003C74898488D540802498BC144886201881A44885AFF448852FE4883C20448FFC875E941FFC0453BC77CBE8B8C
        2480000000488B5C2470418BC1C1E00203F849FFCE0F85ECFEFFFF448BAC24980000008B6C240C448BA4248800000033FF33DB4533DB4533D24533C04585
        FF7E5A488B7424704585ED7E48418BCC8BC5410FAFC94103C80FAF8C2490000000410FAFC18D04814863C8488D543102418BCD0FB642014403D00FB60248
        83C2044403D80FB642FB03D80FB642FA03F848FFC975DE41FFC0453BC77CAB418BCF410FAFCD85C9740A418BC299F7F98BF0EB0233F685C9740B418BC399
        F7F9448BD8EB034533DB85C9740A8BC399F7F9448BD0EB034533D285C9740A8BC799F7F9448BC0EB034533C033D24585FF7E4E4585ED7E42418BCC8BC541
        0FAFC903CA0FAF8C2490000000410FAFC18D04814863C8488B442478488D440102418BCD40887001448818448850FF448840FE4883C00448FFC975E8FFC2
        413BD77CB233C04883C428415F415E415D415C5F5E5D5BC3
        )

        VarSetCapacity(PixelateBitmap, StrLen(MCode_PixelateBitmap)//2)
        Loop % StrLen(MCode_PixelateBitmap)//2      ;%
            NumPut("0x" SubStr(MCode_PixelateBitmap, (2*A_Index)-1, 2), PixelateBitmap, A_Index-1, "UChar")
        DllCall("VirtualProtect", Ptr, &PixelateBitmap, Ptr, VarSetCapacity(PixelateBitmap), "uint", 0x40, A_PtrSize ? "UPtr*" : "UInt*", 0)
    }

    Gdip_GetImageDimensions(pBitmap, Width, Height)

    if (Width != Gdip_GetImageWidth(pBitmapOut) || Height != Gdip_GetImageHeight(pBitmapOut))
        return -1
    if (BlockSize > Width || BlockSize > Height)
        return -2

    E1 := Gdip_LockBits(pBitmap, 0, 0, Width, Height, Stride1, Scan01, BitmapData1)
    E2 := Gdip_LockBits(pBitmapOut, 0, 0, Width, Height, Stride2, Scan02, BitmapData2)
    if (E1 || E2)
        return -3

    E := DllCall(&PixelateBitmap, Ptr, Scan01, Ptr, Scan02, "int", Width, "int", Height, "int", Stride1, "int", BlockSize)

    Gdip_UnlockBits(pBitmap, BitmapData1), Gdip_UnlockBits(pBitmapOut, BitmapData2)
    return 0
}

;#####################################################################################

Gdip_ToARGB(A, R, G, B)
{
    return (A << 24) | (R << 16) | (G << 8) | B
}

;#####################################################################################

Gdip_FromARGB(ARGB, ByRef A, ByRef R, ByRef G, ByRef B)
{
    A := (0xff000000 & ARGB) >> 24
    R := (0x00ff0000 & ARGB) >> 16
    G := (0x0000ff00 & ARGB) >> 8
    B := 0x000000ff & ARGB
}

;#####################################################################################

Gdip_AFromARGB(ARGB)
{
    return (0xff000000 & ARGB) >> 24
}

;#####################################################################################

Gdip_RFromARGB(ARGB)
{
    return (0x00ff0000 & ARGB) >> 16
}

;#####################################################################################

Gdip_GFromARGB(ARGB)
{
    return (0x0000ff00 & ARGB) >> 8
}

;#####################################################################################

Gdip_BFromARGB(ARGB)
{
    return 0x000000ff & ARGB
}

;#####################################################################################

StrGetB(Address, Length=-1, Encoding=0)
{
    ; Flexible parameter handling:
    if Length is not integer
    Encoding := Length,  Length := -1

    ; Check for obvious errors.
    if (Address+0 < 1024)
        return

    ; Ensure 'Encoding' contains a numeric identifier.
    if Encoding = UTF-16
        Encoding = 1200
    else if Encoding = UTF-8
        Encoding = 65001
    else if SubStr(Encoding,1,2)="CP"
        Encoding := SubStr(Encoding,3)

    if !Encoding ; "" or 0
    {
        ; No conversion necessary, but we might not want the whole string.
        if (Length == -1)
            Length := DllCall("lstrlen", "uint", Address)
        VarSetCapacity(String, Length)
        DllCall("lstrcpyn", "str", String, "uint", Address, "int", Length + 1)
    }
    else if Encoding = 1200 ; UTF-16
    {
        char_count := DllCall("WideCharToMultiByte", "uint", 0, "uint", 0x400, "uint", Address, "int", Length, "uint", 0, "uint", 0, "uint", 0, "uint", 0)
        VarSetCapacity(String, char_count)
        DllCall("WideCharToMultiByte", "uint", 0, "uint", 0x400, "uint", Address, "int", Length, "str", String, "int", char_count, "uint", 0, "uint", 0)
    }
    else if Encoding is integer
    {
        ; Convert from target encoding to UTF-16 then to the active code page.
        char_count := DllCall("MultiByteToWideChar", "uint", Encoding, "uint", 0, "uint", Address, "int", Length, "uint", 0, "int", 0)
        VarSetCapacity(String, char_count * 2)
        char_count := DllCall("MultiByteToWideChar", "uint", Encoding, "uint", 0, "uint", Address, "int", Length, "uint", &String, "int", char_count * 2)
        String := StrGetB(&String, char_count, 1200)
    }

    return String
}