AHK: Экранная лупа (Страница 2 из 3)

#NoEnv
#Persistent
#SingleInstance Force

OnExit, Uninitialize
SetBatchLines, -1

Gui, +E0x80000
Gui, +AlwaysOnTop -Caption
Gui,Show,w320 h240, MagnifierWindowAHK
Gui,+LastFound
WinGet,guiHwnd,Id


WinSet, Transparent, 255


hInstance := DllCall("GetWindowLong"
	, "UInt", guiHwnd
	, "UInt", GWL_HINSTANCE:=-6)


DllCall("LoadLibrary", "str", "magnification.dll")
DllCall("magnification.dll\MagInitialize")


WS_CHILD := 0x40000000
WS_VISIBLE := 0x10000000
MS_SHOWMAGNIFIEDCURSOR := 0x1

magHwnd := DllCall("CreateWindowEx"
	, "UInt", 0
	, "Str", "Magnifier"
	, "Str", "MagnifierWindow"
	, "UInt", WS_CHILD | MS_SHOWMAGNIFIEDCURSOR | WS_VISIBLE
	, "Int", 0
	, "Int", 0
	, "Int", 320
	, "Int", 240
	, "UInt", guiHwnd
	, "UInt", 0
	, "UInt", hInstance
	, "UInt", 0)



; Magnification transform matrix

Matrix := "1|0|0|"
        . "0|1|0|"
        . "0|0|1"

StringSplit, Matrix, Matrix, |

VarSetCapacity(magMatrix, 36, 0)
Loop, 9
{
	NumPut(Matrix, magMatrix, (A_Index-1)*4, "float")
}

DllCall("magnification.dll\MagSetWindowTransform"
	, "UInt", magHwnd
	, "UInt", &magMatrix)

loop
DllCall("magnification.dll\MagSetWindowSource"
	, "UInt", magHwnd
	, "Int", -110
	, "Int", 110
	, "Int", 320
	, "Int", 240)

return

Escape::
GuiEscape:
GuiClose:	
Uninitialize:
	Gui, Destroy 
	DllCall("magnification.dll\MagUninitialize")
	ExitApp

VarSetCapacity(rect, 16, 0)
NumPut(-110, rect, 0, "int")
NumPut(110, rect, 4, "int")
NumPut(320, rect, 8, "int")
NumPut(240, rect, 12, "int")
loop
{
   DllCall("magnification.dll\MagSetWindowSource", "ptr", magHwnd, ptr, &rect)
   sleep 50
}

#SingleInstance, Force
#NoEnv
SetBatchLines, -1
CoordMode, Mouse

If !pToken := Gdip_Startup()
{
	MsgBox, 48, gdiplus error!, Gdiplus failed to start. Please ensure you have gdiplus on your system
	ExitApp
}
OnExit, Exit

Gui, -Caption +E0x80000 +AlwaysOnTop +ToolWindow +OwnDialogs +E0x08000000 +HWNDhGui  ; +E0x20
Gui Show, NA, test 

x:= 505
y:= 505
w:= 600
h:= 600 
xv := 400
yv := 200

Blur := 22

hdcSrc := GetDCEx(0)
hdcDest := CreateCompatibleDC()
GoTo Update 
 
1::  
Update:
	; Gui, hide
	; KeyWait, 1
	hBitmap := CreateDIBSection(w, h, hdcDest)
	SelectObject(hdcDest, hBitmap)  
	StretchBlt(hdcDest, 0, 0, w, h, hdcSrc, xv, yv, w,  h) 
	pBitmap := Gdip_CreateBitmapFromHBITMAP(hBitmap)
	DeleteObject(hBitmap)
	pBlurBitmap := Gdip_BlurBitmap(pBitmap, Blur)
	Gdip_DisposeImage(pBitmap)
	G := Gdip_GraphicsFromHDC(hdcDest)
	Gdip_DrawImage(G, pBlurBitmap, 0, 0, w, h, 0, 0, w, h)
	Gdip_DisposeImage(pBlurBitmap) 
	Gdip_DeleteGraphics(G) 
	UpdateLayeredWindow(hGui, hdcDest, xv, yv, w, h)
	Gui, Show, NA  
	Return 

esc::
Exit: 
	DeleteDC(hdcSrc) 
	DeleteDC(hdcDest)  
	Gdip_Shutdown(pToken)
	ExitApp 

gui, +hwndhwnd
Gui, color, 000001
gui, add, button, gExt,Toggle
gui, show, w300 h200, Glass

ext()
{
	static toggle:=0
	global hwnd
	toggle:=!toggle
	WinSet,TransColor, % toggle ? "000001" : "off", % "ahk_id " hwnd
	Dwm_ExtendFrameIntoClientArea(hwnd,toggle?-1:0)
	return
}

Dwm_ExtendFrameIntoClientArea(hwnd,l:=0,r:=0,t=0,b:=0)
{
	;	Extends the window frame into the client area.
	;	Input:
	;			hwnd, unique id to the window to which to extend window frame
	;			l,r,t,b is left, right top and bottom margins, respectively. Use negative to create "sheet of glass"-effect
	; 	Output:
	;			hresult, error msg. 0 is ok!
	;	Notes:
	;			https://msdn.microsoft.com/en-us/library/windows/desktop/aa969512(v=vs.85).aspx
	;			https://msdn.microsoft.com/en-us/library/windows/desktop/bb773244(v=vs.85).aspx (margins struct)
	VarSetCapacity(margin,16,0)
	NumPut(l,margin,0,"Int")
	NumPut(r,margin,4,"Int")
	NumPut(t,margin,8,"Int")
	NumPut(b,margin,12,"Int")
	hr:=DllCall("Dwmapi.dll\DwmExtendFrameIntoClientArea", "Uint", hwnd, "Uint", &margin)
	return hr	; 0 is ok!
}

Dwm_EnableBlurBehindWindow(hwnd,onOff,x1:=0,y1:=0,x2:=0,y2:=0,fTransitionOnMaximized:=0)
{
	;
	; 	Enables the blur effect on a specified window.
	;	Input:
	;		hwnd, The handle to the window on which the blur behind data is applied.
	;		onOff, 1 to turn the effect on, 0 offset
	;		x1,...,y2, The region within the client area where the blur behind will be applied. Let be 0 to apply the blur behind on the entire client area.
	;		fTransitionOnMaximized, 1 if the window's colorization should transition to match the maximized windows; otherwise, 0.
	;	Output:
	;		hresult, error msg. 0 is ok!
	;	Url:
	;		https://msdn.microsoft.com/en-us/library/windows/desktop/aa969508(v=vs.85).aspx - DwmEnableBlurBehindWindow function
	;
	
	
	;	DWM_BLURBEHIND structure:
	;	Url:
	;		https://msdn.microsoft.com/en-us/library/windows/desktop/aa969500(v=vs.85).aspx
	; 	Create region
	hrgn:=DllCall("Gdi32.dll\CreateRectRgn", "Int", x1, "Int", y1, "Int", x2, "Int", y2)

	VarSetCapacity(DWM_BLURBEHIND,12+A_PtrSize,0)
	NumPut(1|2|4,DWM_BLURBEHIND,0,"Uint")								; dwFlags
	NumPut(onOff,DWM_BLURBEHIND,4,"Int")								; fEnable
	NumPut(hrgn,DWM_BLURBEHIND,8,"Uint")								; hrgn
	NumPut(fTransitionOnMaximized,DWM_BLURBEHIND,8+A_PtrSize,"Int")		; fTransitionOnMaximized
	
	hr:= DllCall("Dwmapi.dll\DwmEnableBlurBehindWindow", "Uint", hwnd, "Uint", &DWM_BLURBEHIND)
	DllCall("Gdi32.dll\DeleteObject", "Uint", hrgn)						; The region is not needed after the call.
	return hr ; 0 is ok!
}

ToolTip % NumGet(srcheader, 0, "UInt" ) "х" NumGet(srcheader, 4, "UInt" )

#NoEnv
#Persistent
#SingleInstance Force

OnExit, Uninitialize

DllCall("LoadLibrary", "str", "magnification.dll")
DllCall("magnification.dll\MagInitialize")

Gui, +AlwaysOnTop -Caption +toolwindow +HWNDhGui 
Gui,Show, w320 h240 na, MagnifierWindowAHK

hInstance := DllCall("GetWindowLong"
	, "Ptr", hGui
	, "UInt", GWL_HINSTANCE:=-6)

WS_CHILD := 0x40000000
WS_VISIBLE := 0x10000000
MS_SHOWMAGNIFIEDCURSOR := 0x1 
	
magHwnd := DllCall("CreateWindowEx"
	, "UInt", 0
	, "Str", "Magnifier"
	, "Str", "MagnifierWindow"
	, "UInt",   MS_SHOWMAGNIFIEDCURSOR | WS_VISIBLE | WS_CHILD
	, "Int", 0
	, "Int", 0
	, "Int", 320
	, "Int", 240
	, "Ptr", hGui
	, "UInt", 0
	, "Ptr", hInstance
	, "UInt", 0)
	
DllCall("magnification.dll\MagSetImageScalingCallback"
	, "Ptr", magHwnd
	, "Int", RegisterCallback("MagImageScalingCallback", "Fast"))

VarSetCapacity(rect, 16, 0)
NumPut(0, rect, 0, "int")
NumPut(0, rect, 4, "int")
NumPut(320, rect, 8, "int")
NumPut(240, rect, 12, "int")

DllCall("magnification.dll\MagSetWindowSource", "ptr", magHwnd, ptr, &rect)  
return

MagImageScalingCallback(hwnd, srcdata, srcheader, destdata, destheader, unclipped, clipped, dirty) { 
	ToolTip % NumGet(srcheader, 0, "UInt" ) "`n" NumGet(srcheader, 4, "UInt" )
}

Escape:: 
Uninitialize: 
	DllCall("magnification.dll\MagUninitialize")
	ExitApp

  DWORD        bV5Size;
  LONG         bV5Width;
  LONG         bV5Height;
  WORD         bV5Planes;
  WORD         bV5BitCount;
  DWORD        bV5Compression;
  DWORD        bV5SizeImage;
  LONG         bV5XPelsPerMeter;
  LONG         bV5YPelsPerMeter;
  DWORD        bV5ClrUsed;
  DWORD        bV5ClrImportant;
  DWORD        bV5RedMask;
  DWORD        bV5GreenMask;
  DWORD        bV5BlueMask;
  DWORD        bV5AlphaMask;
  DWORD        bV5CSType;
  CIEXYZTRIPLE bV5Endpoints;
  DWORD        bV5GammaRed;
  DWORD        bV5GammaGreen;
  DWORD        bV5GammaBlue;
  DWORD        bV5Intent;
  DWORD        bV5ProfileData;
  DWORD        bV5ProfileSize;
  DWORD        bV5Reserved;

def_Struct := "
(LTrim Join
  DWORD        bV5Size;
  LONG         bV5Width;
  LONG         bV5Height;
  WORD         bV5Planes;
  WORD         bV5BitCount;
  DWORD        bV5Compression;
  DWORD        bV5SizeImage;
  LONG         bV5XPelsPerMeter;
  LONG         bV5YPelsPerMeter;
  DWORD        bV5ClrUsed;
  DWORD        bV5ClrImportant;
  DWORD        bV5RedMask;
  DWORD        bV5GreenMask;
  DWORD        bV5BlueMask;
  DWORD        bV5AlphaMask;
  DWORD        bV5CSType;
  Ptr          bV5Endpoints;
  DWORD        bV5GammaRed;
  DWORD        bV5GammaGreen;
  DWORD        bV5GammaBlue;
  DWORD        bV5Intent;
  DWORD        bV5ProfileData;
  DWORD        bV5ProfileSize;
  DWORD        bV5Reserved;
)"

oStruct := new DllStruct(def_Struct)

msgbox % oStruct.GetSize()




; ======================================================================================================================
; AHK_L 1.1 +
; ======================================================================================================================
; Function:         Class definitions for windows structures used with DllCall
; AHK version:      1.1.05.06 (U 32) / (U64)
; Language:         English
; Tested on:        Win XPSP3, Win VistaSP2 (x86) / Win 7 (x64)
; Version:          0.0.01.09/2011-12-09/just me
; Remarks:          To create a structure create a new instance of the class using
;                      MyStruct := New DllStruct(StructStr)
;
;                   The parameter "StructStr" describes the fields of the structure as follows:
;                   "TYPE name[n];"
;                        TYPE            : Datatype, for valid types see AHKTypes and WINTypes below
;                        name (optional) : Name to access the field with the methods described below. If name is not 
;                                          specified, you have to access the field by it's 1-based index, otherwise
;                                          TYPE and name must be seperated with at least one space.
;                                          If name is preceded with a "*" the TYPE will be changed to "UPTR".
;                        [n]  (optional) : Number of occurrences, if [n] is not specified it defaults to 1.
;                                          To access a certain occurrence with Get/SetData methods you have to pass
;                                          the 1-based index within the parameter Index. String types (CHAR [n], 
;                                          TCHAR [n], WCHAR [n]) are always accessed as strings.
;                                          To supply names for occurences append a colon (:) to the counter (n)
;                                          followed by the names seperated by commas (,) and the closing bracket,
;                                          e.g. "[4: Left, Top, Right, Bottom]". To access an occurence by name just
;                                          pass the name instead of the numeric index.
;                        ;               : Each field description must be closed with a semicolon
;
;                   Alignment and padding:
;                   By default, each structure member is aligned to start at an address which is a multiple of its
;                   length. In addition the structure is padded to set the size to be a multiple of its longest
;                   member when needed. This can be changed by specifing "Align n;" within "StructStr" where n may
;                   be 0, 1, 2, 4, or 8. It changes alignment for all subsequent structure members be a multiple of n
;                   or their size, whatever is smaller. "Align 0;" restores the default alignment.
;                   Since inluding of embedded structures by name is not supported, the script doesn't notice the start
;                   or end of these structures. But sometimes the structure's size has to be aligned, especially
;                   in 64-bit environments. To avoid displacements you should enclose the structure decleration in
;                   braces followed by a semicolon, e.g. "{; HWND hwndFrom; UINT_PTR idFrom; UINT code; };" (NMHDR).
; 
;                   The following public methods provide access to the structure's memory/fields (see below): 
;                   Init           Sets structure's memory to binary NULL
;                   GetData        Gets the current value of a field
;                   SetData        Sets the value of a field
;                   GetCount       Returns the number of occurrences of a field defined as TYPE [nn]
;                   GetPtr         Returns a pointer to the structure or one of the fields
;                   GetSize        Returns the size of the structure or one of the fields in bytes
;
;                   It's also possible to access fields using the object syntax "Class.Property". To access
;                   a subitem of a field with multiple occurences (e.g. "LONG [4];") you must use the array syntax
;                   Class.Property[4] or Class.Property["Name"]. 
;                   The notation "Class.Property.4" is not supported and will yield a blank result.
;
;                   Fields with multiple occurrences may be accessed as a whole if no subitem index is passed. To 
;                   set the values you have to pass an appropriate array containing all values, reading access returns
;                   an array containing them.   
;
;                   Names of "private" properties/methods are prefixed with underscores, they must not be
;                   set/called by the script!
;                   
;                   You can find the description of windows data types at 
;                   http://msdn.microsoft.com/en-us/library/aa383751%28VS.85%29.aspx
; ======================================================================================================================
; This software is provided 'as-is', without any express or implied warranty.
; In no event will the authors be held liable for any damages arising from the use of this software.
; ======================================================================================================================
;=======================================================================================================================
Class DllStruct {
   ; ===================================================================================================================
   ; Base Class Definition
   ; ===================================================================================================================
   Class _Base {
      ; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      ; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      ; Meta-Functions +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      ; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      ; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      ; ================================================================================================================
      ; CONSTRUCTOR __New - you must not instantiate instances
      ; ================================================================================================================
      __New(P*) {
         Return False
      }
      ; ================================================================================================================
      ; __Get      Get pseudo properties 
      ; ================================================================================================================
      __Get(Name, Index = 0) {
         Return This.GetData(Name, Index)
      }
      ; ================================================================================================================
      ; __Set      Set pseudo properties
      ; ================================================================================================================
      __Set(Name, Params*) {
         If !IsObject(Params) || (Params.MaxIndex() > 2)
            Return ""
         If (Params.MaxIndex() = 1) {
            Index := 0
            Value := Params[1]
         } Else {
            Index := Params[1]
            Value := Params[2]
         }
         Return This.SetData(Name, Value, Index)
      }
      ; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      ; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      ; Private Methods ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      ; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      ; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      ; ================================================================================================================
      ; PRIVATE METHOD _IsInt()
      ; ================================================================================================================
      _IsInt(Value) {
         If Value Is Not Integer
            Return False
         Return True
      }
      ; ================================================================================================================
      ; PRIVATE METHOD _IsIn()
      ; ================================================================================================================
      _IsIn(Value, MatchList) {
         If Value Not In %MatchList%
            Return False
         Return True
      }
      ; ================================================================================================================
      ; PRIVATE METHOD _StructHasField()
      ; ================================================================================================================
      _StructHasField(ByRef Name) {
         StringUpper, Name, Name
         If !(This._IsInt(Name)) {
            If !This._StructObj.HasKey(Name) {
               This.Error := True
               Return False
            }
            Name := This._StructObj[Name]
         }
         If !This._StructArr.HasKey(Name) {
            This.Error := True
            Return False
         }
         Return True
      }
      ; ================================================================================================================
      ; PRIVATE METHOD _FieldHasIndex()
      ; ================================================================================================================
      _FieldHasIndex(ByRef Index, Field) {
         If !(This._IsInt(Index)) {
            If Field.Names.HasKey(Index) {
               Index := Field.Names[Index]
               Return True
            } Else {
               This.Error := True
               Return False
            }
         }
         If (Index < 0) || (Index > Field.Cnt) {
            This.Error := True
            Return False
         }
         Return True
      }
      ; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      ; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      ; PUBLIC Interface +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      ; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      ; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      ; ================================================================================================================
      ; METHOD Init           Sets structure's memory to NULL
      ; Return values:        On success  - True
      ;                       On failure  - False, This.Error is set
      ; ================================================================================================================
      Init() {
         This.Error := False
         If !(This._Ptr) || !(This._Alloc) {
            This.Error := True
            Return False
         }
         DllCall("Kernel32.dll\RtlZeroMemory", "Ptr", This._Ptr, "Ptr", This._Size)
         If (ErrorLevel) {
            This.Error := True
            Return False
         }
         Return True
      }
      ; ================================================================================================================
      ; METHOD GetData        Get current value of structure field
      ; Parameters:           Name        - Name or index of the field
      ;                       Index       - Optional: 1-based index of subitem (Name[nn])
      ; Return values:        On success  - Field value
      ;                       On failure  - False, This.Error is set
      ; Remarks:              To access a certain field "Name" must contain the 1-based field index or the name defined
      ;                       in the structure description string.
      ; ================================================================================================================
      GetData(Name, Index = 0) {
         This.Error := False
         If !This._StructHasField(Name) {
            This.Error := True
            Return False
         }
         Field := This._StructArr[Name]
         If !This._FieldHasIndex(Index, Field) {
            This.Error := True
            Return False
         }
         If (Index = 0) && (Field.Cnt > 1) {
            Value := []
            Loop, % Field.Cnt
               Value.Insert(NumGet(This._Ptr + 0, Field.Pos + ((A_Index - 1) * Field.Len), Field.Type))
            Return Value
         }
         If (Index > 0)
            Index--
         If (Field.Type = "ASTR") || (Field.Type = "WSTR") {
            CP := (Field.Type = "WSTR" ? "UTF-16" : "CP0")
            Len := (Field.Type = "WSTR" ? Field.Len // 2 : Field.Len)
            Value := StrGet(This._Ptr + Field.Pos, Len, CP)
         } Else {
            Value := NumGet(This._Ptr + 0, Field.Pos + (Index * Field.Len), Field.Type)
         }
         Return Value
      }
      ; ================================================================================================================
      ; METHOD SetData        Set value of a structure field
      ; Parameters:           Name        - Name or index of the field
      ;                       Value       - New value 
      ;                       Index       - Optional: 1-based index of subitem (Name[nn])
      ; Return values:        On success  - True
      ;                       On failure  - False, This.Error is set
      ; Remarks:              To access a certain field "Name" must contain the 1-based field index or the name defined
      ;                       in the structure description string.
      ; ================================================================================================================
      SetData(Name, Value, Index = 0) {
         This.Error := False
         If !This._StructHasField(Name) {
            This.Error := True
            Return False
         }
         Field := This._StructArr[Name]
         If !This._FieldHasIndex(Index, Field) {
            This.Error := True
            Return False
         }
         If (Index = 0) && IsObject(Value) && (Value.MaxIndex() = Field.Cnt) {
            For I, V In Value
               NumPut(V, This._Ptr + 0, Field.Pos + ((I - 1) * Field.Len), Field.Type)
            Return True
         }
         If (Index > 0)
            Index--
         If (Field.Type = "ASTR") || (Field.Type = "WSTR") {
            CP := (Field.Type = "WSTR" ? "UTF-16" : "CP0")
            Len := (Field.Type = "WSTR" ? Field.Len // 2 : Field.Len)
            StrPut(Value, This._Ptr + Field.Pos, Len, CP)
         } Else {
            NumPut(Value, This._Ptr + 0, Field.Pos + (Index * Field.Len), Field.Type)
         }
         Return True
      }
      ; ================================================================================================================
      ; METHOD GetCount       Returns the number of occurrences of a field defined as TYPE [nn]
      ; Parameters:           Name        - Name or index of the field
      ; Return values:        On success  - Integer value > 0
      ;                       On failure  - False, This.Error is set
      ; Remarks:              To access a certain field "Name" must contain the 1-based field index or the name defined
      ;                       in the structure description string.
      ; ================================================================================================================
      GetCount(Name) {
         This.Error := False
         If !(This._Ptr) {
            This.Error := True
            Return False
         }
         If !This._StructHasField(Name) {
            This.Error := True
            Return False
         }
         Field := This._StructArr[Name]
         Return (Field.Cnt)
      }
      ; ================================================================================================================
      ; METHOD GetPtr         Returns a pointer to the structure or one of the fields
      ; Parameters:           Name        - Optional: Name or index of the field
      ; Return values:        On success  - Address of the structure or the field passed in Name
      ;                       On failure  - False, This.Error is set
      ; Remarks:              To access a certain field "Name" must contain the 1-based field index or the name defined
      ;                       in the structure description string.
      ; ================================================================================================================
      GetPtr(Name = "") {
         This.Error := False
         If !(This._Ptr) {
            This.Error := True
            Return False
         }
         If (Name = "")
            Return This._Ptr
         If !This._StructHasField(Name) {
            This.Error := True
            Return False
         }
         Field := This._StructArr[Name]
         Return (This._Ptr + Field.Pos)
      }
      ; ================================================================================================================
      ; METHOD GetSize        Returns the size of the structure or one of the fields in bytes
      ; Parameters:           Name        - Optional: Name or index of the field
      ; Return values:        On success  - Size in bytes of the structure or the field passed in Name
      ;                       On failure  - False, This.Error is set
      ; Remarks:              To access a certain field "Name" must contain the 1-based field index or the name defined
      ;                       in the structure description string.
      ; ================================================================================================================
      GetSize(Name = "") {
         This.Error := False
         If !(This._Size) {
            This.Error := True
            Return False
         }
         If (Name = "")
            Return This._Size
         If !This._StructHasField(Name) {
            This.Error := True
            Return False
         }
         Field := This._StructArr[Name]
         Return (Field.Len * Field.Cnt)
      }
   }
   ; ===================================================================================================================
   ; Helper Class for Windows Types
   ; ===================================================================================================================
   Class _WINTypes {
      Static ATOM := "USHORT"
      Static BOOL := "INT"
           , BOOLEAN := "UCHAR"
           , BYTE := "UCHAR"
      Static COLORREF := "UINT"
      Static DWORD32 := "UINT"
           , DWORD64 := "UINT64"
           , DWORD := "UINT"
           , DWORD_PTR := "UPTR"
           , DWORDLONG := "UINT64"
      Static HACCEL := "UPTR"
           , HALF_PTR := (A_PtrSize = 8 ? "INT" : "SHORT")
           , HANDLE := "UPTR"
           , HBITMAP := "UPTR"
           , HBRUSH := "UPTR"
           , HCOLORSPACE := "UPTR"
           , HCONV := "UPTR"
           , HCONVLIST := "UPTR"
           , HCURSOR := "UPTR"
           , HDC := "UPTR"
           , HDDEDATA := "UPTR"
           , HDESK := "UPTR"
           , HDROP := "UPTR"
           , HDWP := "UPTR"
           , HENHMETAFILE := "UPTR"
           , HFILE := "INT"
           , HFONT := "UPTR"
           , HGDIOBJ := "UPTR"
           , HGLOBAL := "UPTR"
           , HHOOK := "UPTR"
           , HICON := "UPTR"
           , HINSTANCE := "UPTR"
           , HKEY := "UPTR"
           , HKL := "UPTR"
           , HLOCAL := "UPTR"
           , HMENU := "UPTR"
           , HMETAFILE := "UPTR"
           , HMODULE := "UPTR"
           , HMONITOR := "UPTR"
           , HPALETTE := "UPTR"
           , HPEN := "UPTR"
           , HRESULT := "INT"
           , HRGN := "UPTR"
           , HRSRC := "UPTR"
           , HSZ := "UPTR"
           , HWINSTA := "UPTR"
           , HWND := "UPTR"
      Static INT32 := "INT"
           , INT_PTR := "PTR"
      Static LANGID := "USHORT"
           , LCID := "UINT"
           , LCTYPE := "UINT"
           , LGRPID := "UINT"
           , LONG32 := "INT"
           , LONG64 := "INT64"
           , LONG := "INT"
           , LONG_PTR := "PTR"
           , LONGLONG := "INT64"
           , LPARAM := "PTR"
           , LPBOOL := "UPTR"
           , LPBYTE := "UPTR"
           , LPCOLORREF := "UPTR"
           , LPCSTR := "UPTR"
           , LPCTSTR := "UPTR"
           , LPCVOID := "UPTR"
           , LPCWSTR := "UPTR"
           , LPDWORD := "UPTR"
           , LPHANDLE := "UPTR"
           , LPINT := "UPTR"
           , LPLONG := "UPTR"
           , LPSTR := "UPTR"
           , LPTSTR := "UPTR"
           , LPVOID := "UPTR"
           , LPWORD := "UPTR"
           , LPWSTR := "UPTR"
           , LRESULT := "PTR"
      Static PBOOL := "PTR"
           , PBOOLEAN := "PTR"
           , PBYTE := "PTR"
           , PCHAR := "PTR"
           , PCSTR := "PTR"
           , PCTSTR := "PTR"
           , PCWSTR := "PTR"
           , PDWORD32 := "PTR"
           , PDWORD64 := "PTR"
           , PDWORD := "PTR"
           , PDWORD_PTR := "PTR"
           , PDWORDLONG := "PTR"
           , PFLOAT := "PTR"
           , PHALF_PTR := "PTR"
           , PHANDLE := "UPTR"
           , PHKEY := "UPTR"
           , PINT32 := "UPTR"
           , PINT64 := "UPTR"
           , PINT := "UPTR"
           , PINT_PTR := "UPTR"
           , PLCID := "UPTR"
           , PLONG32 := "UPTR"
           , PLONG64 := "UPTR"
           , PLONG := "UPTR"
           , PLONG_PTR := "UPTR"
           , PLONGLONG := "UPTR"
           , POINTER_32 := "UINT"
           , POINTER_64 := "PTR"
           , POINTER_SIGNED := "PTR"
           , POINTER_UNSIGNED := "UPTR"
           , PSHORT := "UPTR"
           , PSIZE_T := "UPTR"
           , PSSIZE_T := "UPTR"
           , PSTR := "UPTR"
           , PTBYTE := "UPTR"
           , PTCHAR := "UPTR"
           , PTSTR := "UPTR"
           , PUCHAR := "UPTR"
           , PUHALF_PTR := "UPTR"
           , PUINT32 := "UPTR"
           , PUINT64 := "UPTR"
           , PUINT := "UPTR"
           , PUINT_PTR := "UPTR"
           , PULONG32 := "UPTR"
           , PULONG64 := "UPTR"
           , PULONG := "UPTR"
           , PULONG_PTR := "UPTR"
           , PULONGLONG := "UPTR"
           , PUSHORT := "UPTR"
           , PVOID := "UPTR"
           , PWCHAR := "UPTR"
           , PWORD := "UPTR"
           , PWSTR := "UPTR"
      Static SC_HANDLE := "UPTR"
           , SC_LOCK := "UPTR"
           , SERVICE_STATUS_HANDLE := "UPTR"
           , SIZE_T := "UPTR"
           , SSIZE_T := "PTR"
      Static TBYTE := (A_ISUNICODE ? "USHORT" : "UCHAR")
           , TCHAR := (A_ISUNICODE ? "USHORT" : "UCHAR")
      Static UHALF_PTR := (A_PtrSize = 8 ? "UINT" : "USHORT")
           , UINT32 := "UINT"
           , UINT_PTR := "UPTR"
           , ULONG32 := "UINT"
           , ULONG64 := "UINT64"
           , ULONG := "UINT"
           , ULONG_PTR := "UPTR"
           , ULONGLONG := "UINT64"
           , USN := "INT64"
      Static VOID := "PTR"
      Static WCHAR := "USHORT"
           , WORD := "USHORT"
           , WPARAM := "UPTR"
   }
   ; +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
   ; +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
   ; CLASS Properties and Methods ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
   ; +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
   ; +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
   ; ===================================================================================================================
   ; CONSTRUCTOR __New
   ; Parameters:        StructStr   - String describing the structure fields
   ;                    Pointer     - Optional: Pointer to the structure as returned from SendMessage or API-Calls
   ; Return values:     On success  - new object
   ;                    On failure  - False, ErrorLevel contains additional informations
   ; ===================================================================================================================
   __New(StructStr, Pointer = "") {
      Static AHKTypes := {CHAR: 1, SHORT: 2, INT: 4, INT64: 8, PTR: A_PtrSize
                        , UCHAR: 1, USHORT: 2, UINT: 4, UINT64: 8, UPTR: A_PtrSize}
      Static StructsP := {RECT: "{;LONG [4: Left, Top, Right, Bottom];};"
                        , POINT: "{;LONG [2: X, Y];};"
                        , POINTS: "{;SHORT [2: X, Y];};"}
      ; Create class variables -----------------------------------------------------------------------------------------
      This._DllStruct := ""   ; Structure variable                               (Binary)
      This._StructArr := []   ; Array of structure fields                        (Object)
      This._StructObj := {}   ; Object for field names                           (Object)
      This._Alloc := False    ; Did the class allocate memory?                   (BOOL)
      This._Ptr := 0          ; Structure pointer                                (Pointer)
      This._Size := 0         ; Structure size                                   (Integer)
      This.Error := False     ; Set to True in case of errors                    (BOOL)
      ; ----------------------------------------------------------------------------------------------------------------
      Align := FieldIndex := MaxLen := MaxStructLen := Pad := Ptr := Size := StructAlign := 0
      InStruct := False
      StructStr := RegExReplace(StructStr, "[\r\n]")
      StructStr := RTrim(StructStr, ";")
      Loop, Parse, StructStr, `;
      {
         If !(A_LoopField) {
            ErrorLevel := "Improper structure declaration!"
            Return False
         }
         StringUpper, Part, A_LoopField
         Part := RegExReplace(Trim(Part), "\s+", " ")
         Rep := ""
         If RegExMatch(Part, "\[(?P<ep>[^\]]+)\]$", R) {
            Rep := RegExReplace(Rep, "\s+")
            Part := RegExReplace(Part, "\s*\[.*$")
         }
         StringSplit, Parts, Part, %A_Space%
         If (Parts0 > 2) {
            ErrorLevel := "Improper field declaration: " . Part . "!"
            Return False
         }
         ; Check for alignment presetting
         If (Parts1 = "Align") {
            If (Parts0 = 2) && (StrLen(Parts2) = 1) && InStr("01248", Parts2) {
               If (InStruct) {
                  StructAlign := Parts2
               } Else {
                  Align := Parts2
               }
               Continue
            }
            ErrorLevel := "Invalid alignment value""" . Parts2 . """!"
            Return False
         }
         ; Check for explicit padding
         If (Parts1 = "Pad") {
            If (Parts0 = 2) && (StrLen(Parts2) = 1) && InStr("012345678", Parts2) {
               Size += Parts2
               Continue
            }
            ErrorLevel := "Invalid padding value""" . Parts2 . """!"
            Return False
         }
         ; Check for embedded structures
         If (Parts1 = "{") {  ; start of structure
            If (InStruct) {
               ErrorLevel := "Improper use of ""{""!"
               Return False
            }
            ; Set / initialize structure related variables
            InStruct := True
            MaxStructLen := 0
            StructAlign := Align
            Continue
         }
         If (Parts1 = "}") {  ; end of structure
            If !(InStruct) || (MaxStructLen = 0) {
               ErrorLevel := "Improper use of ""}""!"
               Return False
            }
            ; Align structure's size if required and reset structure related variables
            StructAlign := (StructAlign) && (StructAlign < MaxStructLen) ? StructAlign : MaxStructLen
            If (Pad := Mod(Size, StructAlign))
               Size += StructAlign - Pad
            MaxStructLen := 0
            InStruct := False
            StructAlign := 0
            Continue
         }
         ; 
         Cnt  := 1
         If (Rep) && !RegExMatch(Rep, "^\d+", Cnt) {
            ErrorLevel := "Improper repetition factor """ . Rep . """!"
            Return False
         }
         If (Parts0 = 2) {
            If (SubStr(Parts2, 1, 1) = "*") {
               Parts1 := "UPTR"
               Parts2 := RegExReplace(Parts2, "^\*+")
            }
         }
         Type := Parts1
         If This._WINTypes.HasKey(Parts1)
            Type := This._WINTypes[Parts1]
         If !AHKTypes.HasKey(Type) {
            ErrorLevel := "Invalid data type """ . Parts1 . """!"
            Return False
         }
         Len := AHKTypes[Type]
         If (Len > MaxLen)
            MaxLen := Len
         If (Len > MaxStructLen)
            MaxStructLen := Len
         If (Pad := Mod(Size, ((Align) && (Align < Len))? Align : Len))
            Size += Len - Pad
         Pos := Size
         If (Cnt > 1) {
            If (Parts1 = "WCHAR")
               Type := "WSTR"
            Else If (Parts1 = "CHAR")
               Type := "ASTR"
            Else If (Parts1 = "TCHAR")
               Type := (A_IsUnicode ? "WSTR" : "ASTR")
         }
         If (Type = "ASTR") || (Type = "WSTR") {
            Len := Cnt * (Type = "WSTR" ? 2 : 1)
            Rep := ""
            Cnt := 1
         }
         Names := {}
         If InStr(Rep, ":") {
            StringReplace, Rep, Rep, %Cnt%:
            StringSplit, Name, Rep, `,
            If (Name0 = Cnt) {
               Loop, %Name0%
                  Names[Name%A_Index%] := A_Index
            }
         }
         FieldIndex++
         This._StructArr[FieldIndex] := {"Type": Type, "Pos": Pos, "Len": Len, "Cnt": Cnt, "Names": Names}
         Size += (Len * Cnt)
         If (Parts0 = 2)
            This._StructObj[Parts2] := FieldIndex
      }
      Align := (Align) && (Align < MaxLen) ? Align : MaxLen
      If (Pad := Mod(Size, Align))
         Size += Align - Pad
      If (Pointer <> "") {
         This._Ptr := Pointer
         This._Size := Size
      } Else {
         If (This.SetCapacity("_DllStruct", Size) <> Size)
            Return False
         This._Size := Size
         Ptr := This.GetAddress("_DllStruct")
         If !(Ptr)
            Return False
         This._Ptr := Ptr
         This._Alloc := True
      }
      This.Base := This._Base
      If This._Alloc
         This.Init()
   }
}

#NoEnv
#Persistent
#SingleInstance Force

OnExit, Uninitialize

DllCall("LoadLibrary", "str", "magnification.dll")
DllCall("magnification.dll\MagInitialize")

Gui, +AlwaysOnTop -Caption +ToolWindow +HWNDhGui 
Gui, Show, x320 y0 w320 h240 NA, MagnifierWindowAHK

Global hPic
Gui 2: -Caption +AlwaysOnTop +ToolWindow
Gui, 2: Margin, 0,0  
Gui, 2: Add, text, w320 h240 0xE hwndhPic ; SS_BITMAP = 0xE 
Gui, 2: Show, x640 y0 NA

hInstance := DllCall("GetWindowLong"
	, "Ptr", hGui
	, "UInt", GWL_HINSTANCE:=-6)

WS_CHILD := 0x40000000
WS_VISIBLE := 0x10000000
MS_SHOWMAGNIFIEDCURSOR := 0x1 
	
magHwnd := DllCall("CreateWindowEx"
	, "UInt", 0
	, "Str", "Magnifier"
	, "Str", "MagnifierWindow"
	, "UInt",   MS_SHOWMAGNIFIEDCURSOR | WS_VISIBLE | WS_CHILD
	, "Int", 0
	, "Int", 0
	, "Int", 320
	, "Int", 240
	, "Ptr", hGui
	, "UInt", 0
	, "Ptr", hInstance
	, "UInt", 0)

DllCall("magnification\MagSetWindowFilterList","Ptr",magHwnd,"Int",0,"Int",1,"Ptr*", WinExist("ahk_class Notepad++"))  ;  MW_FILTERMODE_EXCLUDE

DllCall("magnification.dll\MagSetImageScalingCallback"
	, "Ptr", magHwnd
	, "Int", RegisterCallback("MagImageScalingCallback", "Fast"))

VarSetCapacity(rect, 16, 0)
NumPut(0, rect, 0, "int")
NumPut(0, rect, 4, "int")
NumPut(320, rect, 8, "int")
NumPut(240, rect, 12, "int")

Loop
	DllCall("magnification.dll\MagSetWindowSource", "ptr", magHwnd, ptr, &rect)   
return 

MagImageScalingCallback(hwnd, srcdata, srcheader, destdata, destheader, unclipped, clipped, dirty) { 
	Static BI_RGB := 0, CBM_INIT := 6, DIB_RGB_COLORS := 0
		, Ptr := A_PtrSize = 8 ? "UPtr" : "UInt"
		, STM_SETIMAGE := 0x172, IMAGE_BITMAP := 0x0
		, _ := VarSetCapacity(BITMAPV5HEADER, 124, 0)
		, __ := VarSetCapacity(BITMAPINFO, 44, 0)
	
	bV5Width := NumGet(srcheader + 0, 0, "UInt")
	bV5Height := NumGet(srcheader + 0, 4, "UInt") 
	
	NumPut(124, BITMAPV5HEADER, 0, "UInt")  		;	DWORD		bV5Size;
	NumPut(bV5Width, BITMAPV5HEADER, 4, "UInt")		;	LONG		bV5Width;
	NumPut(bV5Height, BITMAPV5HEADER, 8, "UInt")	;	LONG		bV5Height;
	NumPut(1, BITMAPV5HEADER, 12, "Short")			;	WORD		bV5Planes;
	NumPut(32, BITMAPV5HEADER, 14, "Short")			;	WORD		bV5BitCount;
	NumPut(BI_RGB, BITMAPV5HEADER, 16, "UInt")		;	DWORD		bV5Compression; 
	
	NumPut(44, BITMAPINFO, 0, "UInt")  				;	DWORD biSize;
	NumPut(bV5Width, BITMAPINFO, 4, "UInt")  		;	LONG  biWidth;
	NumPut(bV5Height, BITMAPINFO, 8, "UInt")  		;	LONG  biHeight;
	NumPut(1, BITMAPINFO, 12, "Short")  			;	WORD  biPlanes;
	NumPut(32, BITMAPINFO, 14, "Short")  			;	WORD  biBitCount;
	NumPut(BI_RGB, BITMAPINFO, 16, "UInt")  		;	DWORD biCompression;
 
	hDC := DllCall("GetDC", Ptr, hwnd)
	
	hBMP := DllCall("CreateDIBitmap"
		, Ptr, hDC
		, Ptr, &BITMAPV5HEADER
		, "UInt", CBM_INIT
		, Ptr,  srcdata
		, Ptr, &BITMAPINFO
		, "UInt", DIB_RGB_COLORS)
		
		
	hBitmap := DllCall("CopyImage", Ptr, hBMP, "UInt", 0, "Int", 320, "Int", 240, "UInt", 0)
	
	SendMessage, STM_SETIMAGE, IMAGE_BITMAP, hBitmap,, ahk_id %hPic%
	
	DllCall("DeleteDC", Ptr, hDC)
	DllCall("DeleteObject", Ptr, hBMP)
	DllCall("DeleteObject", Ptr, hBitmap)
	return 1
}

Escape:: 
Uninitialize: 
	DllCall("magnification.dll\MagUninitialize")
	ExitApp