[Imgbb]
ClientID=YOUR_IMGBB_API_KEY

#NoEnv
#SingleInstance, force
#MaxHotkeysPerInterval 200
SetWinDelay, 0
SetBatchLines, -1
SetTitleMatchMode, 3
CoordMode, Mouse
OnExit("ShutdownApplication")

global App := {Config: {}, Settings: {}, Menu: {}, Selection: {}, Windows: {}}

hIcon16 := CreateIconFromBase64(GetBase64String(16), 16)
Menu, Tray, Icon, HICON:*%hIcon16%

hIcon32 := CreateIconFromBase64(GetBase64String(32), 32)
DllCall("SendMessage", "Ptr", A_ScriptHwnd, "UInt", WM_SETICON := 0x80, "Ptr", ICON_BIG := 1, "Ptr", hIcon32)
App.GdipToken := GdipStartup()

				    ;  секция          ключ               имя переменной        умолчание
IniReadConfigSect("Color-Transparent", "ARGB"             , "ARGB"             , 0x82FFC700)

IniReadConfigSect("Output_Settings"  , "Output"           , "Output"           , "File"
									 , "Extension"        , "Ext"              , "png"
									 , "JPEG_Quality"     , "JPEGQuality"      , 100
									 , "Out_Directory"    , "OutDirectory"     , A_ScriptDir)

IniReadConfigSect("Program_Settings" , "Capture_Cursor"   , "CaptureCursor"    , 0
									 , "Show_Preview"     , "ShowPreview"      , 1
									 , "Notify"           , "Notify"           , 1
									 , "Resize_Pointers"  , "ResizePointers"   , "Cursors"
									 , "InterpolationMode", "InterpolationMode", 3)
										 
IniReadHotkeysSect("Hotkeys"         , "GetArea"          , "GetArea"          , "$F12"
								     , "GetActiveWindow"  , "GetActiveWindow"  , ">+PrintScreen"
								     , "GetScreen"        , "GetScreen"        , "PrintScreen"
								     , "ShowHideSelWindow", "ShowHideSelWindow", "Pause"
								     , "SelWindowToCenter", "SelWindowToCenter", "ScrollLock"
								     , "SelectPreview"    , "SelectPreview"    , "<^Space"
								     , "OpenOutputFolder" , "OpenOutputFolder" , " "
								     , "SelectAreaOverlay", "SelectAreaOverlay", "F4"
								     , "QuickSelectAreaOverlay", "QuickSelectAreaOverlay", "^LButton")
NormalizeLoadedSettings()

Menu, Tray, NoStandard
Menu, Tray, Add, Справка, ShowHelp
Menu, Tray, Add
Menu, Tray, Add, Вывод, ShowSettingsFromMenu
Menu, Tray, Add, Настройки, ShowSettingsFromMenu
Menu, Tray, Add
App.Menu.TrayHide := MenuHotkeyCaption("Скрыть окно выделения", App.Hotkeys.ShowHideSelWindow)
App.Menu.TrayShow := MenuHotkeyCaption("Показать окно выделения", App.Hotkeys.ShowHideSelWindow)
App.Menu.TrayCenter := MenuHotkeyCaption("Окно выделения в центр экрана", App.Hotkeys.SelWindowToCenter)
App.Menu.TrayOpenOutDir := MenuHotkeyCaption("Открыть папку вывода", App.Hotkeys.OpenOutputFolder)
Menu, Tray, Add, % App.Menu.TrayShow, ToggleSelectionWindow
Menu, Tray, Add, % App.Menu.TrayCenter, CenterSelectionWindow
Menu, Tray, Add, % App.Menu.TrayOpenOutDir, OpenOutputDirectory
if !A_IsCompiled {
	Menu, Tray, Add
	Menu, Tray, Add, Редактировать скрипт, EditScript
	Menu, Tray, Add, Перезагрузка, ReloadScript
}
Menu, Tray, Add
Menu, Tray, Add, Выход, ShutdownApplication

Menu, MainMenu, Add, Вывод, ShowSettingsFromMenu
Menu, MainMenu, Add, Настройки, ShowSettingsFromMenu
Menu, MainMenu, Add
App.Menu.MainArea := MenuHotkeyCaption("Сделать скриншот", App.Hotkeys.GetArea)
App.Menu.MainHide := MenuHotkeyCaption("Скрыть окно выделения", App.Hotkeys.ShowHideSelWindow)
App.Menu.MainOpenOutDir := MenuHotkeyCaption("Открыть папку вывода", App.Hotkeys.OpenOutputFolder)
Menu, MainMenu, Add, % App.Menu.MainArea, CaptureAreaScreenshot
Menu, MainMenu, Add, % App.Menu.MainHide, ToggleSelectionWindow
Menu, MainMenu, Add, % App.Menu.MainOpenOutDir, OpenOutputDirectory
Menu, MainMenu, Add
Menu, MainMenu, Add, Справка, ShowHelp

Menu, Interpolation, Add, Default, SetInterpolationMode
Menu, Interpolation, Add, LowQuality, SetInterpolationMode
Menu, Interpolation, Add, HighQuality, SetInterpolationMode
Menu, Interpolation, Add, Bilinear, SetInterpolationMode
Menu, Interpolation, Add, Bicubic, SetInterpolationMode
Menu, Interpolation, Add, NearestNeighbor, SetInterpolationMode
Menu, Interpolation, Add, HighQualityBilinear, SetInterpolationMode
Menu, Interpolation, Add, HighQualityBicubic, SetInterpolationMode
InterpolationModeString := "Default|LowQuality|HighQuality|Bilinear|"
	. "Bicubic|NearestNeighbor|HighQualityBilinear|HighQualityBicubic"
App.Menu.InterpolationItems := StrSplit(InterpolationModeString, "|")

Menu, Interpolation, Check, % App.Menu.InterpolationItems[App.Config.InterpolationMode]

Menu, PreviewSaveToMenu, Add, файл, PreviewSaveToMenuHandling
Menu, PreviewSaveToMenu, Add, буфер обмена, PreviewSaveToMenuHandling
Menu, PreviewSaveToMenu, Add, imgbb.com, PreviewSaveToMenuHandling

Menu, PreviewSaveOriginalToMenu, Add, файл, PreviewSaveToMenuHandling
Menu, PreviewSaveOriginalToMenu, Add, буфер обмена, PreviewSaveToMenuHandling
Menu, PreviewSaveOriginalToMenu, Add, imgbb.com, PreviewSaveToMenuHandling

Menu, PreviewSaveCurrentToMenu, Add, файл, PreviewSaveCurrentToMenuHandling
Menu, PreviewSaveCurrentToMenu, Add, буфер обмена, PreviewSaveCurrentToMenuHandling
Menu, PreviewSaveCurrentToMenu, Add, imgbb.com, PreviewSaveCurrentToMenuHandling

Menu, ScreenShotMenu, Add, Сохранить в первоначальном размере, ScreenShotMenuHandling
Menu, ScreenShotMenu, Add, Сохранить в первоначальном размере в, :PreviewSaveOriginalToMenu
Menu, ScreenShotMenu, Add, Сохранить в текущем размере, ScreenShotMenuHandling
Menu, ScreenShotMenu, Add, Сохранить в текущем размере в, :PreviewSaveCurrentToMenu
Menu, ScreenShotMenu, Add, Удалить, ScreenShotMenuHandling

Menu, ScreenShotMenu2, Add, Интерполяция при изменении размеров, :Interpolation
Menu, ScreenShotMenu2, Add, Сохранить в, :PreviewSaveToMenu
Menu, ScreenShotMenu2, Add, Сохранить, ScreenShotMenuHandling
Menu, ScreenShotMenu2, Add, Удалить, ScreenShotMenuHandling

Gui, +LastFound -Caption +AlwaysOnTop +Owner
StoreSelectionWindowHwnd()
WinSet, Transparent, 0, % "ahk_id " App.Selection.Hwnd
Gui, Color, % Format("{:X}", App.Config.ARGB & 0xFFFFFF)

Locations = x190 y190|x0 y190|x0 y0|x190 y0|x190 y95|x95 y190|x0 y95|x95 y0
App.Selection.MarkerHwnds := []
Loop, parse, Locations, |			; SS_BITMAP = 0xE
{
	Gui, Add, Text, % "w10 h10 +0xE hidden hwndMarkerHwnd " A_LoopField
	App.Selection.MarkerHwnds.Push(MarkerHwnd)
}
UpdateMarkerColor()

SetResizeHotkeyState("Off")

if !A_Args.Length() {
	CenterSelectionWindow()
} else {
	opts := "x" (A_ScreenWidth - 200)//2 " y" (A_ScreenHeight - 200)//2 " h200 w200 Hide"
	Gui, Show, % opts, ScreenСatcher
}
SetScriptHotkeys(1)

Esc := DllCall("RegisterWindowMessage", "Str", "Esc")
Wheel := DllCall("RegisterWindowMessage", "Str", "Wheel")

OnMessage( Esc,  "WM_ESC")
OnMessage(Wheel, "WM_WHEEL")
OnMessage(0x018, "WM_SHOWWINDOW")
OnMessage(0x020, "WM_OVERLAY_SETCURSOR")
OnMessage(0x201, "WM_LBUTTONDOWN")
OnMessage(0x203, "WM_LBUTTONDBLCLK")
OnMessage(0x204, "WM_RBUTTONDOWN")
OnMessage(0x404, "AHK_NOTIFYICON")
return

;###########################################################################################################
;*************************************** Окно Настроек *****************************************************
;###########################################################################################################

OpenSettingsWindow(ThisMenuItemPos) {
	HideHelpWindow()
	App.Config.RunOnWinStart := IsRunOnWindowsStartEnabled()
	SelectionHwnd := App.Selection.Hwnd
	Gui, 2:Default
	if WindowExistsByHwnd(App.Settings.WindowHwnd) {
		if WindowExistsByHwnd(App.Settings.HotkeysHwnd)
			Gui, 4:Hide
		GuiControl, Choose, % App.Settings.TabHwnd, % ThisMenuItemPos
		SuspendScriptHotkeysForSettings()
		Gui, 2:Show
		UpdateHotkeysTabVisibility()
		return
	}
	SavePreviousSettingsState()
	SuspendScriptHotkeysForSettings()
	Width := 310, Height := 230
	Gui, 2:+LastFound +hwndSettingsHwnd
	App.Settings.WindowHwnd := SettingsHwnd
	App.Windows[2] := Object("Hwnd", SettingsHwnd)
	Gui, Font, s10 q5, Calibri
	Gui, Add, Tab3, gUpdateHotkeysTabVisibility x0 y0 w%Width% h%Height% hwndSettingsTabHwnd AltSubmit -Wrap
		, % "   Цвет| Вывод|Настройки|Горячие клавиши"
	App.Settings.TabHwnd := SettingsTabHwnd
	GuiControl, Choose, % App.Settings.TabHwnd, % ThisMenuItemPos

;********************************** Первая вкладка "Цвет" ***********************************

	Gui, Add, Pic, % "x10 y+10 h184 +0x8 w" Width - 21		; SS_GRAYFRAME = 0x8

	Gui, Font, s10, Segoe UI
	Gui, Add, Text, % "Center c5021AC x15 yp+10 w" Width-30, Настройки цвета и прозрачности
	Gui, Font, s8 q5, Verdana
	Gui, Add, Text, x25 yp+37 w30 cRed Center, Red
	Gui, Add, Text, xp-2 yp+30 wp cGreen Center, Green
	Gui, Add, Text, xp yp+30 wp cBlue Center, Blue
	Gui, Add, Text, xp yp+30 wp cEECC00 Center, Trans

	ColorState := App.Settings.Color := Object()
	ColorState.Red := (App.Config.ARGB & 0xFF0000)>>16
	ColorState.Green := (App.Config.ARGB & 0xFF00)>>8
	ColorState.Blue := App.Config.ARGB & 0xFF
	ColorState.Trans := App.Config.ARGB>>24

	Options := "x65 w" Width - 115 " h20 Range0-255 ToolTip AltSubmit"
	Gui, Add, Slider, gUpdateSelectionColorFromGui %Options% yp-91 hwndRedSliderHwnd, % ColorState.Red
	Gui, Add, Slider, gUpdateSelectionColorFromGui %Options% yp+30 hwndGreenSliderHwnd, % ColorState.Green
	Gui, Add, Slider, gUpdateSelectionColorFromGui %Options% yp+30 hwndBlueSliderHwnd, % ColorState.Blue
	Gui, Add, Slider, gUpdateSelectionTransparencyFromGui %Options% yp+30 hwndTransSliderHwnd, % ColorState.Trans

	Gui, Add, Text, xp+195 yp-89 w30 cRed Center hwndRedValueHwnd, % ColorState.Red
	Gui, Add, Text, xp yp+30 wp cGreen Center hwndGreenValueHwnd, % ColorState.Green
	Gui, Add, Text, xp yp+30 wp cBlue Center hwndBlueValueHwnd, % ColorState.Blue
	Gui, Add, Text, xp yp+30 wp cEECC00 Center hwndTransValueHwnd, % ColorState.Trans
	App.Settings.RedSliderHwnd := RedSliderHwnd
	App.Settings.GreenSliderHwnd := GreenSliderHwnd
	App.Settings.BlueSliderHwnd := BlueSliderHwnd
	App.Settings.TransSliderHwnd := TransSliderHwnd
	App.Settings.RedValueHwnd := RedValueHwnd
	App.Settings.GreenValueHwnd := GreenValueHwnd
	App.Settings.BlueValueHwnd := BlueValueHwnd
	App.Settings.TransValueHwnd := TransValueHwnd

;********************************* Вторая вкладка "Вывод" ************************************

	Gui, Tab, 2
	Gui, Font, s10, Segoe UI
	Gui, Add, Text, % "Center c5021AC x5 y+6 w" Width-10, Как сохранять скриншоты:
	Gui, Font, s8 q5, Verdana
	Gui, Add, Checkbox
		, % "gUpdateOutputTargetFromGui x15 yp+25 hwndOutputFileHwnd" (InStr(App.Config.Output, "File") ? " Checked" : ""), В файл
	Gui, Add, Checkbox
		, % "gUpdateOutputTargetFromGui xp+75 yp hwndOutputClipHwnd" (InStr(App.Config.Output, "Clip") ? " Checked" : ""), В буфер обмена
	Gui, Add, Checkbox
		, % "gUpdateOutputTargetFromGui xp+125 yp hwndOutputImgbbHwnd" (InStr(App.Config.Output, "Imgbb") ? " Checked" : ""), Imgbb.com
	App.Settings.OutputFileHwnd := OutputFileHwnd
	App.Settings.OutputClipHwnd := OutputClipHwnd
	App.Settings.OutputImgbbHwnd := OutputImgbbHwnd

	Gui, Add, Pic, % "x2 yp+26 h2 +0x8 w" Width - 4		; SS_GRAYFRAME = 0x8

	Gui, Font, s10, Segoe UI
	Gui, Add, Text, % "Center c5021AC x5 yp+9 w" Width-10, Тип файлов для вывода
	Gui, Font, s8 q5, Verdana
	Gui, Add, Radio, % "gSetOutputExtensionFromGui x25 yp+23 hwndExtensionPngHwnd" (App.Config.Ext = "png" ? " Checked" : ""), png
	Gui, Add, Radio, % "gSetOutputExtensionFromGui xp+55 yp hwndExtensionJpgHwnd" (App.Config.Ext = "jpg" ? " Checked" : ""), jpg
	Gui, Add, Radio, % "gSetOutputExtensionFromGui xp+55 yp hwndExtensionBmpHwnd" (App.Config.Ext = "bmp" ? " Checked" : ""), bmp
	Gui, Add, Radio, % "gSetOutputExtensionFromGui xp+55 yp hwndExtensionTifHwnd" (App.Config.Ext = "tif" ? " Checked" : ""), tif
	Gui, Add, Radio, % "gSetOutputExtensionFromGui xp+55 yp hwndExtensionGifHwnd" (App.Config.Ext = "gif" ? " Checked" : ""), gif
	App.Settings.ExtensionPngHwnd := ExtensionPngHwnd
	App.Settings.ExtensionJpgHwnd := ExtensionJpgHwnd
	App.Settings.ExtensionBmpHwnd := ExtensionBmpHwnd
	App.Settings.ExtensionTifHwnd := ExtensionTifHwnd
	App.Settings.ExtensionGifHwnd := ExtensionGifHwnd

	Gui, Font, s10, Segoe UI
	Gui, Add, Text, Left c5021AC x20 yp+23, Качество jpg:
	Gui, Add, Slider
		, gSetJpegQuality xp+107 yp w128 h20 Range50-100 ToolTip AltSubmit hwndJpegQualitySliderHwnd, % App.Config.JPEGQuality
	Gui, Font, s8 q5, Verdana
	Gui, Add, Text, Center c5021AC xp+132 yp+2 w30 hwndJpegQualityPercentHwnd, % App.Config.JPEGQuality "`%"
	App.Settings.JpegQualitySliderHwnd := JpegQualitySliderHwnd
	App.Settings.JpegQualityPercentHwnd := JpegQualityPercentHwnd

	Gui, Add, Pic, % "x2 yp+26 h2 +0x8 w" Width - 4		; SS_GRAYFRAME = 0x8

	Gui, Font, s10, Segoe UI
	Gui, Add, Text, % "Center c5021AC x5 yp+9 w" Width-10, Папка для сохранения файлов
	Gui, Font, s8 q5, Verdana
	Gui, Add, Edit, % "hwndOutDirectoryEditHwnd x10 yp+24 h21 w" Width-50, % App.Config.OutDirectory
	App.Settings.OutDirectoryEditHwnd := OutDirectoryEditHwnd
	Gui, Font, s10
	Gui, Add, Button, % "gSelectOutputDirectory x" Width-35 " yp hp w23", ...

;************************** Третья вкладка "Настройки программы" ****************************

	Gui, Tab, 3
	Gui, Font, s8 q5, Verdana
	Gui, Add, Checkbox
		, % "x20 y+15 hwndCaptureCursorHwnd" (App.Config.CaptureCursor ? " Checked" : "")
		, Включать курсор в скриншот
	Gui, Add, Checkbox, % "xp yp+25 hwndShowPreviewHwnd" (App.Config.ShowPreview ? " Checked" : "")
		, Показывать скриншот перед сохранением
	Gui, Add, Checkbox, % "xp yp+25 hwndNotifyHwnd" (App.Config.Notify ? " Checked" : "")
		, Уведомлять о сохранении скриншота

	Gui, Add, Checkbox
		, % "xp yp+25 hwndRunOnWinStartHwnd" (App.Config.RunOnWinStart ? " Checked" : "")
		, Запускать программу при загрузке системы
	App.Settings.CaptureCursorHwnd := CaptureCursorHwnd
	App.Settings.ShowPreviewHwnd := ShowPreviewHwnd
	App.Settings.NotifyHwnd := NotifyHwnd
	App.Settings.RunOnWinStartHwnd := RunOnWinStartHwnd
	Gui, Add, Checkbox, xp yp+25, Проверять обновления при запуске
	; Gui, Add, Pic, % "x2 yp+30 h2 +0x8 w" Width - 4		; SS_GRAYFRAME = 0x8

	Gui, Font, s10, Segoe UI
	Gui, Add, Text, % "Center c5021AC x5 yp+25 w" Width-10
		, Индикаторы при изменении размеров`nокна выделения
	Gui, Font, s8 q5, Verdana
	Gui, Add, Radio, xp+14 yp+40 hwndResizeCursorsHwnd, Изменённые курсоры
	Gui, Add, Radio, xp+153 yp hwndResizeMarkersHwnd, Цветные маркеры
	GuiControl,, % (App.Config.ResizePointers = "Cursors" ? ResizeCursorsHwnd : ResizeMarkersHwnd), 1
	App.Settings.ResizeCursorsHwnd := ResizeCursorsHwnd
	App.Settings.ResizeMarkersHwnd := ResizeMarkersHwnd
	
	Gui, Tab
	
;*************************** Четвёртая вкладка "Горячие клавиши" *****************************

	HotkeysTabPageHwnd := DllCall("GetWindow", "Ptr", App.Settings.TabHwnd, "UInt", GW_HWNDNEXT := 2)
	WinGetPos,,, W, H, ahk_id %HotkeysTabPageHwnd%
	
	Gui, 4: Default
	Gui, +Parent%HotkeysTabPageHwnd% -Caption +ToolWindow +hwndHotkeysHwnd
	App.Settings.HotkeysHwnd := HotkeysHwnd
	Gui, Add, Tab3, % "gFocusSettingsSafeButton x" 5 " y" 5 " w" W - 8 " h" H - 9 " hwndHotkeysSubTabHwnd", Скриншоты|Окна скрипта|Служебные
	App.Settings.HotkeysSubTabHwnd := HotkeysSubTabHwnd
	Handles := []
	HotkeyControls := []
	HotkeyNames := ScreenCatcherHotkeyNames()
	for k, v in [ "Скриншот под окном выделения"
				, "Скриншот активного окна"
				, "Скриншот всего экрана"
				, "Скрыть/показать окно выделения"
				, "Окно выделения в центр экрана"
				, "Выделить превью скриншота"
				, "Открыть папку вывода"
				, "Выбрать область для скриншота"
				, "Быстро выделить область для скриншота" ]
	{
		if k = 4
			Gui, Tab, 2
		if k = 7
			Gui, Tab, 3
		Gui, Font, s10, Segoe UI
		Gui, Add, Text, % "x0 y+8 w" . (Width - 6) . " Center c5021AC", %v%:
		Gui, Font, s11, calibri
		Gui, Add, Edit, % "Center ReadOnly x15 y+5 h23 w" . (Width-36) . " hwndhHotkey" . k
		SetStaticColor(hHotkey%k%, 0xFFFFFF)
		Handles.Push(hHotkey%k%)
		Options := "KDMLR"
		HotkeyControls.Push([HotkeyNames[k], hHotkey%k%, Options])
	}
	Hotkey_Register(HotkeyControls*)
	SetHotkeyControlsFromVars()
	Gui, Show, Hide x0 y0 w%W% h%H%
	App.Settings.MessageHandlers := {}
	App.Settings.MessageHandlers.WM_COMMAND := Func("WM_COMMAND").Bind(Handles)
	App.Settings.MessageHandlers.WM_SETCURSOR := Func("WM_SETCURSOR").Bind(Handles)
	OnMessage( 0x111, App.Settings.MessageHandlers.WM_COMMAND )
	OnMessage( 0x20, App.Settings.MessageHandlers.WM_SETCURSOR )
	
;***********************************************************************************************

	Gui, 2:Default
	
	Gui, Font, s8 q5, Verdana
	Gui, Add, Button, % "gConfirmSettingsFromGui x" Width - 286 " y" Height + 14 " w85 h23", OK
	Gui, Add, Button, gApplySettingsFromGui xp+90 yp wp hp, Применить
	Gui, Add, Button, gCancelSettingsFromGui xp+90 yp wp hp, Отмена
	
	if WinExist("ahk_id " SelectionHwnd) {
		WinGetPos, X1, Y1, W1, H1, ahk_id %SelectionHwnd%
		Gui, Show, % "w" Width-1 " h" Height+51 " Hide", Настройки
		DetectHiddenWindows, On
		WinGetPos,,, W2, H2, % "ahk_id " App.Settings.WindowHwnd
		X := ((X2 := X1 + (W1 - W2)//2) + W2 > A_ScreenWidth) ? A_ScreenWidth - W2 : X2 < 0 ? 0 : X2
		Y := ((Y2 := Y1 + H1 + 20) + H2 < A_ScreenHeight) ? Y2 : (Y2 := Y1 - 20 - H2) < 0 ? 0 : Y2
		Gui, Show, x%X% y%Y%, Настройки
		DetectHiddenWindows, Off
	} else {
		Gui, Show, % "w" Width-1 " h" Height+51, Настройки
	}
	return
}

2GuiEscape() {
	CancelSettingsFromGui()
}

2GuiClose() {
	CancelSettingsFromGui()
}

;^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Конец окна Настроек ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

ScreenShotMenu() {
	ScreenShotMenuHandling()
}

SetInterpolationMode() {
	SetInterpolationModeFromMenu(A_ThisMenuItemPos)
}

ReloadScript() {
	SelectionHwnd := App.Selection.Hwnd
	if WinExist("ahk_id " SelectionHwnd) {
		Reload
		return
	}

	Run, % """" A_AhkPath """ /restart """ A_ScriptFullPath """ HideSelection", % A_ScriptDir
	ExitApp
}

EditScript() {
	Edit
}

ShowHelp() {
	HideSettingsWindow()
	if !IsObject(App.Help)
		App.Help := {}

	HelpText := BuildHelpText()
	if WindowExistsByHwnd(App.Help.WindowHwnd) {
		GuiControl, 6:, % App.Help.TextHwnd, % HelpText
		Gui, 6:Show,, Справка
		return
	}

	Width := 520, TextHeight := 410, Margin := 14, ButtonWidth := 90
	TextWidth := Width - Margin * 2
	WindowHeight := TextHeight + 62

	Gui, 6:+LastFound +hwndHelpHwnd
	App.Help.WindowHwnd := HelpHwnd
	Gui, 6:Margin, %Margin%, %Margin%
	Gui, 6:Font, s10 q5, Segoe UI
	Gui, 6:Add, Edit, % "ReadOnly +VScroll w" TextWidth " h" TextHeight " hwndHelpTextHwnd", % HelpText
	SetStaticColor(HelpTextHwnd, 0xFFFFFF, 0x000000)
	App.Help.TextHwnd := HelpTextHwnd
	Gui, 6:Add, Button, % "gCloseHelpWindow Default x" (Width - Margin - ButtonWidth) " y+10 w" ButtonWidth " h24", OK
	Gui, 6:Show, % "w" Width " h" WindowHeight, Справка
	PostMessage, 0x00B1, 0, 0, , ahk_id %HelpTextHwnd%   ;  EM_SETSEL
	return
}

6GuiEscape() {
	HideHelpWindow()
}

6GuiClose() {
	HideHelpWindow()
}

CloseHelpWindow(CtrlHwnd := "", GuiEvent := "", EventInfo := "", EventErrorLevel := "") {
	HideHelpWindow()
}

HideHelpWindow() {
	if !IsObject(App.Help)
		return
	if WindowExistsByHwnd(App.Help.WindowHwnd)
		Gui, 6:Hide
}

HideSettingsWindow() {
	if WindowExistsByHwnd(App.Settings.HotkeysHwnd)
		Gui, 4:Hide
	if WindowExistsByHwnd(App.Settings.WindowHwnd) {
		Gui, 2:Hide
		ResumeScriptHotkeysAfterSettings()
	}
}

BuildHelpText() {
Text =
(
ScreenCatcher

ScreenCatcher делает снимки экрана, активного окна и выбранной области. Снимок можно сохранить в файл, скопировать в буфер обмена, открыть в предпросмотре или загрузить на Imgbb.

Возможности:
- снимок всего экрана, активного окна или выбранной области;
- выбор области рамкой или быстрым выделением мышью поверх экрана;
- точное позиционирование, центрирование и изменение размера окна выделения;
- предпросмотр снимков: окна можно перемещать, изменять в размере и открывать по ним контекстное меню;
- настройка формата файла, качества JPEG и папки сохранения;
- захват курсора, уведомления и запуск вместе с Windows;
- настройка цвета, прозрачности и маркеров окна выделения.
)
	Text .= "`r`n`r`nГорячие клавиши:`r`n" . BuildHelpHotkeysText()
	Text .= "`r`n`r`nПодсказки:`r`n"
	Text .= "- Если горячая клавиша не назначена, действие можно вызвать из меню трея.`r`n"
	Text .= "- При быстром выделении мышью выберите нужную область; Esc или правая кнопка отменяют выбор.`r`n"
	Text .= "- Горячие клавиши можно изменить в настройках."
	return Text
}

BuildHelpHotkeysText() {
	Labels := ScreenCatcherHotkeyLabels()
	Text := ""
	for k, HotkeyName in ScreenCatcherHotkeyNames()
		Text .= Labels[HotkeyName] ": " HelpHotkeyText(App.Hotkeys[HotkeyName]) "`r`n"
	return RTrim(Text, "`r`n")
}

HelpHotkeyText(HotkeyValue) {
	Text := Hotkey_HKToStr(HotkeyValue)
	return (Text = "Нет" || !IsHotkeyEnabled(HotkeyValue)) ? "не назначена" : Text
}

WindowExistsByHwnd(Hwnd) {
	if !Hwnd
		return false
	DetectHiddenWindowsWasOn := A_DetectHiddenWindows
	DetectHiddenWindows, On
	Exists := WinExist("ahk_id " Hwnd)
	DetectHiddenWindows, %DetectHiddenWindowsWasOn%
	return Exists
}

ShowSettingsFromMenu(ItemName := "", ItemPos := "", MenuName := "") {
	OpenSettingsWindow(SettingsTabFromMenu(MenuName, ItemPos))
}

SettingsTabFromMenu(MenuName, ItemPos) {
	if (MenuName = "Tray")
		return ItemPos - 1
	return ItemPos + 1
}

StoreSelectionWindowHwnd() {
	WinGet, SelectionHwnd
	App.Selection.Hwnd := SelectionHwnd
}

ShutdownApplication() {
	SelectionHwnd := App.Selection.Hwnd

	Loop {
		if (MaxIndex := App.Windows.MaxIndex()) {
			Gui, %MaxIndex%:Destroy
			App.Windows.Remove(MaxIndex, "")
			Sleep, 50
		}
	} until !MaxIndex

	if WinExist("ahk_id " SelectionHwnd)
		Melt(SelectionHwnd, App.Config.ARGB>>24, 0)
	if IsObject(App.Selection.Overlay)
		App.Selection.Overlay.Dispose()

	RestoreCursors()
	GdipShutdown(App.GdipToken)

	SaveSettings()
	ExitApp
}

MenuHotkeyCaption(Text, HotkeyValue) {
	hk := Hotkey_HKToStr(HotkeyValue)
	return Text . (hk = "Нет" ? "" : A_Tab . hk)
}

UpdateMenuHotkeyCaptions() {
	SelectionHwnd := App.Selection.Hwnd

	NewTrayMenuHide := MenuHotkeyCaption("Скрыть окно выделения", App.Hotkeys.ShowHideSelWindow)
	NewTrayMenuShow := MenuHotkeyCaption("Показать окно выделения", App.Hotkeys.ShowHideSelWindow)
	NewTrayMenuCenter := MenuHotkeyCaption("Главное окно в центр экрана", App.Hotkeys.SelWindowToCenter)
	NewTrayMenuOpenOutDir := MenuHotkeyCaption("Открыть папку вывода", App.Hotkeys.OpenOutputFolder)
	NewMainMenuArea := MenuHotkeyCaption("Сделать скриншот", App.Hotkeys.GetArea)
	NewMainMenuHide := MenuHotkeyCaption("Скрыть окно выделения", App.Hotkeys.ShowHideSelWindow)
	NewMainMenuOpenOutDir := MenuHotkeyCaption("Открыть папку вывода", App.Hotkeys.OpenOutputFolder)

	if WinExist("ahk_id " SelectionHwnd)
		Menu, Tray, Rename, % App.Menu.TrayHide, % NewTrayMenuHide
	else
		Menu, Tray, Rename, % App.Menu.TrayShow, % NewTrayMenuShow
	Menu, Tray, Rename, % App.Menu.TrayCenter, % NewTrayMenuCenter
	Menu, Tray, Rename, % App.Menu.TrayOpenOutDir, % NewTrayMenuOpenOutDir

	Menu, MainMenu, Rename, % App.Menu.MainArea, % NewMainMenuArea
	Menu, MainMenu, Rename, % App.Menu.MainHide, % NewMainMenuHide
	Menu, MainMenu, Rename, % App.Menu.MainOpenOutDir, % NewMainMenuOpenOutDir

	App.Menu.TrayHide := NewTrayMenuHide
	App.Menu.TrayShow := NewTrayMenuShow
	App.Menu.TrayCenter := NewTrayMenuCenter
	App.Menu.TrayOpenOutDir := NewTrayMenuOpenOutDir
	App.Menu.MainArea := NewMainMenuArea
	App.Menu.MainHide := NewMainMenuHide
	App.Menu.MainOpenOutDir := NewMainMenuOpenOutDir
}

SaveSettings() {
	S_FormatInteger := A_FormatInteger
	SetFormat, IntegerFast, H
					;  секция          ключ                значение
	IniWriteSect("Color-Transparent", "ARGB"             , App.Config.ARGB)

	SetFormat, IntegerFast, D
	IniWriteSect("Output_Settings"  , "Output"           , App.Config.Output
								    , "Extension"        , App.Config.Ext
								    , "JPEG_Quality"     , App.Config.JPEGQuality
								    , "Out_Directory"    , App.Config.OutDirectory)

	IniWriteSect("Program_Settings" , "Capture_Cursor"   , App.Config.CaptureCursor
									, "Show_Preview"     , App.Config.ShowPreview
									, "Notify"           , App.Config.Notify
									, "Resize_Pointers"  , App.Config.ResizePointers
									, "InterpolationMode", App.Config.InterpolationMode)

	IniWriteSect("Hotkeys"          , "GetArea"          , App.Hotkeys.GetArea
									, "GetActiveWindow"  , App.Hotkeys.GetActiveWindow
									, "GetScreen"        , App.Hotkeys.GetScreen
									, "ShowHideSelWindow", App.Hotkeys.ShowHideSelWindow
									, "SelWindowToCenter", App.Hotkeys.SelWindowToCenter
									, "SelectPreview"    , App.Hotkeys.SelectPreview
									, "OpenOutputFolder" , App.Hotkeys.OpenOutputFolder
									, "SelectAreaOverlay", App.Hotkeys.SelectAreaOverlay
									, "QuickSelectAreaOverlay", App.Hotkeys.QuickSelectAreaOverlay)
	SetFormat, IntegerFast, %S_FormatInteger%
}

SettingsStateVars() {
	return "ARGB|Output|ext|JPEGQuality|OutDirectory|CaptureCursor|ShowPreview|Notify|"
		 . "RunOnWinStart|ResizePointers|GetArea|GetActiveWindow|GetScreen|"
		 . "ShowHideSelWindow|SelWindowToCenter|SelectPreview|OpenOutputFolder|"
		 . "SelectAreaOverlay|QuickSelectAreaOverlay"
}

SavePreviousSettingsState(StateVars := "") {
	if (StateVars = "")
		StateVars := SettingsStateVars()
	App.Settings.Previous := {}
	Loop, parse, StateVars, |
		App.Settings.Previous[A_LoopField] := SettingsStateValue(A_LoopField)
}

RestorePreviousSettingsState(StateVars := "") {
	SelectionHwnd := App.Selection.Hwnd

	Previous := App.Settings.Previous
	if !IsObject(Previous)
		return

	if (App.Config.ARGB != Previous.ARGB)
		ColorChange := App.Config.ARGB

	if WinExist("ahk_id " SelectionHwnd)
		SetResizePointerTimer("Off")

	if (StateVars = "")
		StateVars := SettingsStateVars()
	Loop, parse, StateVars, |
		SetSettingsStateValue(A_LoopField, Previous[A_LoopField])
	App.Config.ResizePointers := NormalizeResizePointersValue(App.Config.ResizePointers)
	SyncSettingsColorFromARGB()
	SetHotkeyControlsFromVars()

	if WinExist("ahk_id " SelectionHwnd)
		SetResizePointerTimer(50)

	if ColorChange {
		if WinExist("ahk_id " SelectionHwnd)
			Melt(SelectionHwnd, ColorChange>>24, 0), PrevExist := 1
		Gui, 1:Color, % Format("{:X}", App.Config.ARGB & 0xFFFFFF)
		UpdateMarkerColor()
		if PrevExist
			PrevExist := "", Melt(SelectionHwnd, App.Config.ARGB>>24, 1)
		ColorChange := ""
	}
}

SyncSettingsColorFromARGB() {
	if !IsObject(App.Settings.Color)
		App.Settings.Color := {}
	App.Settings.Color.Red := (App.Config.ARGB & 0xFF0000)>>16
	App.Settings.Color.Green := (App.Config.ARGB & 0xFF00)>>8
	App.Settings.Color.Blue := App.Config.ARGB & 0xFF
	App.Settings.Color.Trans := App.Config.ARGB>>24
}

SettingsStateValue(Name) {
	for index, HotkeyName in ScreenCatcherHotkeyNames()
		if (Name = HotkeyName)
			return App.Hotkeys[HotkeyName]

	for index, ConfigName in SettingsConfigNames()
		if (Name = ConfigName)
			return App.Config[ConfigName]

	if (Name = "ResizePointers")
		return NormalizeResizePointersValue(App.Config.ResizePointers)
	if (Name = "InterpolationMode")
		return App.Config.InterpolationMode
	return ""
}

SetSettingsStateValue(Name, Value) {
	for index, HotkeyName in ScreenCatcherHotkeyNames() {
		if (Name = HotkeyName) {
			App.Hotkeys[HotkeyName] := Value
			return
		}
	}

	for index, ConfigName in SettingsConfigNames() {
		if (Name = ConfigName) {
			App.Config[ConfigName] := Value
			return
		}
	}

	if (Name = "ResizePointers")
		App.Config.ResizePointers := NormalizeResizePointersValue(Value)
	else if (Name = "InterpolationMode")
		App.Config.InterpolationMode := Value
}

SettingsConfigNames() {
	return [ "ARGB", "Output", "ext", "JPEGQuality", "OutDirectory"
		   , "CaptureCursor", "ShowPreview", "Notify", "RunOnWinStart" ]
}

CloseSettingsWindow() {
	if IsObject(App.Settings.MessageHandlers) {
		OnMessage( 0x111, App.Settings.MessageHandlers.WM_COMMAND, 0 )
		OnMessage( 0x20, App.Settings.MessageHandlers.WM_SETCURSOR, 0 )
		App.Settings.MessageHandlers := ""
	}
	Gui, 2:Destroy
	ResumeScriptHotkeysAfterSettings()
}

SuspendScriptHotkeysForSettings() {
	if App.Settings.ScriptHotkeysSuspended
		return
	SetScriptHotkeys(0)
	App.Settings.ScriptHotkeysSuspended := true
}

ResumeScriptHotkeysAfterSettings() {
	if !App.Settings.ScriptHotkeysSuspended
		return
	App.Settings.ScriptHotkeysSuspended := false
	SetScriptHotkeys(1)
}

ApplySettingsFromGui(CtrlHwnd := "", GuiEvent := "", EventInfo := "", EventErrorLevel := "") {
	if !ApplyHotkeySettings()
		return false
	ApplyProgramSettings()
	CheckImgbbClientIdOnApply()
	SaveSettings()
	SavePreviousSettingsState()
	return true
}

CheckImgbbClientIdOnApply() {
	if !InStr(App.Config.Output, "Imgbb")
		return

	EnsureImgbbClientId()
}

EnsureImgbbClientId() {
	IniPath := IniFilePath()
	MissingValue := Chr(1) . "__ScreenCatcherMissing__"
	IniRead, ClientID, % IniPath, Imgbb, ClientID, % MissingValue
	if (ClientID = MissingValue) {
		EmptyValue := ""
		IniWrite, % EmptyValue, % IniPath, Imgbb, ClientID
		ClientID := ""
	}

	if (Trim(ClientID) != "")
		return ClientID

	Message := "Для отправки скриншотов на Imgbb нужен API key.`n`n"
		. "Зарегистрируйтесь: https://imgbb.com/`n"
		. "Получите ключ: https://api.imgbb.com/`n`n"
		. "Впишите ключ в файл ScreenCatcher.ini:`n"
		. "[Imgbb]`nClientID=..."
	SetOwnDialogsForOpenWindows()
	MsgBox, 48, Нужен ключ Imgbb, %Message%
	Run, % "notepad.exe """ IniPath """"
	return ""
}

SetOwnDialogsForOpenWindows() {
	if WindowExistsByHwnd(App.Selection.Hwnd)
		Gui, 1:+OwnDialogs
	if WindowExistsByHwnd(App.Settings.WindowHwnd)
		Gui, 2:+OwnDialogs
	if WindowExistsByHwnd(App.Settings.HotkeysHwnd)
		Gui, 4:+OwnDialogs
	if WindowExistsByHwnd(App.Menu.HighlightHwnd) || WinExist("Imgbb.com ahk_class AutoHotkeyGUI")
		Gui, 5:+OwnDialogs
	if IsObject(App.Help) && WindowExistsByHwnd(App.Help.WindowHwnd)
		Gui, 6:+OwnDialogs
	if IsObject(App.Selection.Overlay) && IsObject(App.Selection.Overlay.overlay)
			&& WindowExistsByHwnd(App.Selection.Overlay.overlay.hwnd)
		Gui, SelectionOverlay:+OwnDialogs

	for GuiNumber, WindowData in App.Windows {
		if IsObject(WindowData) && WindowExistsByHwnd(WindowData.Hwnd)
			Gui, %GuiNumber%:+OwnDialogs
	}
}

ConfirmSettingsFromGui(CtrlHwnd := "", GuiEvent := "", EventInfo := "", EventErrorLevel := "") {
	if !ApplySettingsFromGui()
		return false
	CloseSettingsWindow()
	return true
}

CancelSettingsFromGui(CtrlHwnd := "", GuiEvent := "", EventInfo := "", EventErrorLevel := "") {
	RestorePreviousSettingsState()
	CloseSettingsWindow()
}

ScreenCatcherHotkeyNames() {
	return ["GetArea", "GetActiveWindow", "GetScreen", "ShowHideSelWindow"
		  , "SelWindowToCenter", "SelectPreview", "OpenOutputFolder"
		  , "SelectAreaOverlay", "QuickSelectAreaOverlay"]
}

ScreenCatcherHotkeyLabels() {
	return { GetArea:           "Скриншот под окном выделения"
		   , GetActiveWindow:   "Скриншот активного окна"
		   , GetScreen:         "Скриншот всего экрана"
		   , ShowHideSelWindow: "Скрыть/показать окно выделения"
		   , SelWindowToCenter: "Окно выделения в центр экрана"
		   , SelectPreview:     "Выделить превью скриншота"
		   , OpenOutputFolder:  "Открыть папку вывода"
		   , SelectAreaOverlay: "Начать выделение мышью"
		   , QuickSelectAreaOverlay: "Быстро выделить область мышью" }
}

ScreenCatcherHotkeyIndex(Name) {
	for k, v in ScreenCatcherHotkeyNames() {
		if (v = Name)
			return k
	}
	return 0
}

GetScriptHotkeys() {
	return { GetArea: App.Hotkeys.GetArea
		   , GetActiveWindow: App.Hotkeys.GetActiveWindow
		   , GetScreen: App.Hotkeys.GetScreen
		   , ShowHideSelWindow: App.Hotkeys.ShowHideSelWindow
		   , SelWindowToCenter: App.Hotkeys.SelWindowToCenter
		   , SelectPreview: App.Hotkeys.SelectPreview
		   , OpenOutputFolder: App.Hotkeys.OpenOutputFolder
		   , SelectAreaOverlay: App.Hotkeys.SelectAreaOverlay
		   , QuickSelectAreaOverlay: App.Hotkeys.QuickSelectAreaOverlay }
}

SetHotkeyControlsFromVars() {
	for k, name in ScreenCatcherHotkeyNames()
		Hotkey_Set(name, App.Hotkeys[name])
}

ApplyHotkeySettings() {
	if (Duplicate := FindDuplicateHotkey()) {
		ShowDuplicateHotkey(Duplicate)
		return false
	}

	oldHotkeys := GetScriptHotkeys()
	for k, name in ScreenCatcherHotkeyNames()
		App.Hotkeys[name] := Hotkey_Value(name)

	if !ScriptHotkeysEqual(oldHotkeys, GetScriptHotkeys()) {
		SetScriptHotkeys(0, oldHotkeys)
		if !App.Settings.ScriptHotkeysSuspended
			SetScriptHotkeys(1)
		UpdateMenuHotkeyCaptions()
	}
	return true
}

ScriptHotkeysEqual(a, b) {
	for k, v in a
		if (v != b[k])
			return false
	return true
}

IsHotkeyEnabled(HotkeyValue) {
	return Trim(HotkeyValue) != ""
}

UpdateHotkeysTabVisibility(CtrlHwnd := "", GuiEvent := "", EventInfo := "", EventErrorLevel := "") {
	ControlGet, NTab, Tab,,, % "ahk_id " App.Settings.TabHwnd
	if NTab = 4
		Gui, 4:Show, NA
	else
		Gui, 4:Show, Hide
}

UpdateSelectionColorFromGui(CtrlHwnd := "", GuiEvent := "", EventInfo := "", EventErrorLevel := "") {
	ReadColorControls()
	UpdateSelectionColor()
	UpdateColorValueLabels()
	UpdateMarkerColor()
}

ReadColorControls() {
	GuiControlGet, Red, 2:, % App.Settings.RedSliderHwnd
	GuiControlGet, Green, 2:, % App.Settings.GreenSliderHwnd
	GuiControlGet, Blue, 2:, % App.Settings.BlueSliderHwnd
	GuiControlGet, Trans, 2:, % App.Settings.TransSliderHwnd
	App.Settings.Color.Red := Red
	App.Settings.Color.Green := Green
	App.Settings.Color.Blue := Blue
	App.Settings.Color.Trans := Trans
}

UpdateColorValueLabels() {
	ColorState := App.Settings.Color
	GuiControl, 2:, % App.Settings.RedValueHwnd, % ColorState.Red
	GuiControl, 2:, % App.Settings.GreenValueHwnd, % ColorState.Green
	GuiControl, 2:, % App.Settings.BlueValueHwnd, % ColorState.Blue
	GuiControl, 2:, % App.Settings.TransValueHwnd, % ColorState.Trans
}

UpdateSelectionColor() {
	ColorState := App.Settings.Color
	ColorValue := (ColorState.Red<<16)|(ColorState.Green<<8)|ColorState.Blue
	App.Config.ARGB := (App.Config.ARGB & 0xFF000000)|ColorValue
	SetFormat, IntegerFast, H
	Gui, 1:Color, % ColorValue
	SetFormat, IntegerFast, D
}

UpdateSelectionTransparencyFromGui(CtrlHwnd := "", GuiEvent := "", EventInfo := "", EventErrorLevel := "") {
	GuiControlGet, Trans, 2:, % App.Settings.TransSliderHwnd
	App.Settings.Color.Trans := Trans
	UpdateSelectionTransparency()
	UpdateColorValueLabels()
}

UpdateMarkerColor() {
	MarkerColor := (App.Config.ARGB & 0xFFFFFF)^0xFFFFFF
	for index, MarkerHwnd in App.Selection.MarkerHwnds
		SetColorToControl(MarkerHwnd, MarkerColor)
}

UpdateSelectionTransparency() {
	SelectionHwnd := App.Selection.Hwnd

	Trans := App.Settings.Color.Trans
	WinSet, Transparent, % Trans, ahk_id %SelectionHwnd%
	App.Config.ARGB := Trans<<24|(App.Config.ARGB & 0xFFFFFF)
}

UpdateOutputTargetFromGui(CtrlHwnd := "", GuiEvent := "", EventInfo := "", EventErrorLevel := "") {
	UpdateOutputTarget(OutputControlName(CtrlHwnd), CtrlHwnd)
}

OutputControlName(CtrlHwnd) {
	switch CtrlHwnd {
		case App.Settings.OutputFileHwnd  : return "File"
		case App.Settings.OutputClipHwnd  : return "Clip"
		case App.Settings.OutputImgbbHwnd : return "Imgbb"
		default: return ""
	}
}

UpdateOutputTarget(ControlName, CtrlHwnd := "") {
	if (ControlName = "")
		return
	GuiControlGet, OutVar, 2:, %CtrlHwnd%
	if OutVar
		App.Config.Output .= ControlName
	else {
		Output := App.Config.Output
		StringReplace, Output, Output, % ControlName,, 1
		App.Config.Output := Output
	}
}

SetOutputExtensionFromGui(CtrlHwnd := "", GuiEvent := "", EventInfo := "", EventErrorLevel := "") {
	SetOutputExtension(OutputExtensionFromHwnd(CtrlHwnd))
}

OutputExtensionFromHwnd(CtrlHwnd) {
	switch CtrlHwnd {
		case App.Settings.ExtensionPngHwnd: return "png"
		case App.Settings.ExtensionJpgHwnd: return "jpg"
		case App.Settings.ExtensionBmpHwnd: return "bmp"
		case App.Settings.ExtensionTifHwnd: return "tif"
		case App.Settings.ExtensionGifHwnd: return "gif"
		default: return ""
	}
}

SetOutputExtension(Extension) {
	if (Extension != "")
		App.Config.Ext := Extension
}

SetJpegQuality() {
	GuiControlGet, JPEGQualityValue, 2:, % App.Settings.JpegQualitySliderHwnd
	App.Config.JPEGQuality := JPEGQualityValue
	GuiControl, 2:, % App.Settings.JpegQualityPercentHwnd, % App.Config.JPEGQuality "`%"
}

FocusSettingsSafeButton() {
	GuiControl, 2:Focus, Button17
}

ApplyProgramSettings() {
	SelectionHwnd := App.Selection.Hwnd

	OldResizePointers := App.Config.ResizePointers
	OldRunOnWinStart := App.Config.RunOnWinStart
	GuiControlGet, CaptureCursorChecked, 2:, % App.Settings.CaptureCursorHwnd
	App.Config.CaptureCursor := CaptureCursorChecked
	GuiControlGet, ShowPreviewChecked, 2:, % App.Settings.ShowPreviewHwnd
	App.Config.ShowPreview := ShowPreviewChecked
	GuiControlGet, NotifyChecked, 2:, % App.Settings.NotifyHwnd
	App.Config.Notify := NotifyChecked
	GuiControlGet, RunOnWinStartChecked, 2:, % App.Settings.RunOnWinStartHwnd
	App.Config.RunOnWinStart := RunOnWinStartChecked
	GuiControlGet, CursorsChecked, 2:, % App.Settings.ResizeCursorsHwnd
	App.Config.ResizePointers := CursorsChecked ? "Cursors" : "Markers"

	if (OldRunOnWinStart != App.Config.RunOnWinStart)
		SetRunOnWindowsStart(App.Config.RunOnWinStart)

	if (OldResizePointers != App.Config.ResizePointers && WinExist("ahk_id " SelectionHwnd)) {
		SetResizePointerTimer("Off", OldResizePointers)
		SetResizePointerTimer(50, App.Config.ResizePointers)
	}
}

SelectOutputDirectory() {
	SelectionHwnd := App.Selection.Hwnd

	Old_OutDirectory := App.Config.OutDirectory
	SelectionWasVisible := WinExist("ahk_id " SelectionHwnd)
	if (SelectionWasVisible)
		ToggleSelectionWindow()
	Gui, 2:+OwnDialogs
	CurrentOutDirectory := App.Config.OutDirectory
	FileSelectFolder, OutDir, *%CurrentOutDirectory%, 3, Выберите папку для вывода:
	App.Config.OutDirectory := OutDir ? OutDir : App.Config.OutDirectory
	if (App.Config.OutDirectory != Old_OutDirectory)
		GuiControl, 2:, % App.Settings.OutDirectoryEditHwnd, % App.Config.OutDirectory
	if (SelectionWasVisible && !WinExist("ahk_id " SelectionHwnd))
		ToggleSelectionWindow()
}

IsRunOnWindowsStartEnabled() {
	FileGetShortcut, % GetRunOnWindowsStartShortcutPath(), OutTarget,, OutArgs
	return (OutTarget = A_ScriptFullPath && OutArgs = 1)
}

SetRunOnWindowsStart(Enable) {
	ShortcutPath := GetRunOnWindowsStartShortcutPath()
	if (Enable)
		FileCreateShortcut, % A_ScriptFullPath, % ShortcutPath, % A_ScriptDir, 1
	else
		FileDelete, % ShortcutPath
}

GetRunOnWindowsStartShortcutPath() {
	return A_Startup "\" RegExReplace(A_ScriptName, "(.*)\..*", "$1.lnk")
}

OpenOutputDirectory() {
	Run, % App.Config.OutDirectory
}

UpdateResizePointerHover(Mode) {
	if (Mode = "Cursors")
		App.Selection.ResizeHandle := Cursors1()
	else
		App.Selection.ResizeHandle := Markers1()
}

GuiSize() {
	MoveSelectionResizeMarkers(A_GuiWidth, A_GuiHeight)
}

MoveSelectionResizeMarkers(Width, Height) {
	GuiControl, Move, Static1, % "x" Width - 10 "y" Height - 10
	GuiControl, Move, Static2, % "x0 y" Height - 10
	GuiControl, Move, Static3, % "x0 y0"
	GuiControl, Move, Static4, % "x" Width - 10 "y0"
	GuiControl, Move, Static5, % "x" Width - 10 "y" (Height - 10)/2
	GuiControl, Move, Static6, % "x" (Width - 10)/2 "y" Height - 10
	GuiControl, Move, Static7, % "x0 y" (Height - 10)/2
	GuiControl, Move, Static8, % "x" (Width - 10)/2 "y0"
}

GuiContextMenu() {
	RestoreCursors()
	Menu, MainMenu, Show
}

; Окно выделения в центр экрана
CenterSelectionWindow() {
	SelectionHwnd := App.Selection.Hwnd

	if WinExist("ahk_id " SelectionHwnd)
		Melt(SelectionHwnd, App.Config.ARGB>>24, 0)
	else {
		Menu, Tray, Rename, % App.Menu.TrayShow, % App.Menu.TrayHide
		SetResizePointerTimer(50)
	}
	Gui, 1:Show, % "x" (A_ScreenWidth - 200)//2 " y" (A_ScreenHeight - 200)//2 " h200 w200 Hide"
	Melt(SelectionHwnd, App.Config.ARGB>>24, 1)
}

GuiClose() {
	ToggleSelectionWindow()
}

GuiEscape() {
	ToggleSelectionWindow()
}

HideShow() {
	ToggleSelectionWindow()
}

ToggleSelectionWindow() {
	SelectionHwnd := App.Selection.Hwnd

	Exist := WinExist("ahk_id " SelectionHwnd)
	Melt(SelectionHwnd, App.Config.ARGB>>24, !Exist)
	Menu, Tray, Rename, % Exist ? App.Menu.TrayHide : App.Menu.TrayShow
							, % Exist ? App.Menu.TrayShow : App.Menu.TrayHide
	SetResizePointerTimer(Exist ? "Off" : 50)
	( Exist && NormalizeResizePointersValue(App.Config.ResizePointers) = "Cursors" && RestoreCursors() )
}

CaptureAreaScreenshot() {
	CoordMode, Pixel, Screen
	MouseGetPos, mx, my
	prev_color := 0
	Loop {
		PixelGetColor, cur_color, %mx%, %my%
		if (cur_color = prev_color)
			break
		prev_color := cur_color
		Sleep, 30
	}
	GetScreenshot("Area")
}

SetInterpolationModeFromMenu(MenuItemPos) {
	Menu, Interpolation, UnCheck, % App.Menu.InterpolationItems[App.Config.InterpolationMode]
	App.Config.InterpolationMode := MenuItemPos
	Menu, Interpolation, Check, % App.Menu.InterpolationItems[App.Config.InterpolationMode]
}

FindDuplicateHotkey() {
	Names := ScreenCatcherHotkeyNames()
	Loop % Names.MaxIndex() {
		Name1 := Names[A_Index]
		Value1 := Hotkey_Value(Name1)
		if !IsHotkeyEnabled(Value1)
			continue
		i := A_Index + 1
		Loop % Names.MaxIndex() - A_Index {
			Name2 := Names[i]
			Value2 := Hotkey_Value(Name2)
			if (IsHotkeyEnabled(Value2) && Hotkey_Equal(Value1, Value2))
				return {Name: Name2, OtherName: Name1, Hwnd: Hotkey_ID(Name2), Value: Value2}
			i++
		}
	}
	return ""
}

ShowDuplicateHotkey(Duplicate) {
	Labels := ScreenCatcherHotkeyLabels()
	ActivateHotkeyControl(Duplicate.Name)
	Hwnd := Duplicate.Hwnd
	WinGetPos, X, Y, W, H, ahk_id %Hwnd%
	Text := "Эта горячая клавиша уже назначена:`n" Labels[Duplicate.OtherName]
	new ToolTip({ text: Text, x: X, y: Y + H + 8, TimeOut: -3500
				, BackColor: 0x0055aa, TextColor: "white", FontSize: 10, FontName: "calibri" })
	BlinkWindow(Hwnd)
}

ActivateHotkeyControl(Name) {
	Index := ScreenCatcherHotkeyIndex(Name)
	if !Index
		return
	SubTab := Index < 4 ? 1 : Index < 7 ? 2 : 3
	GuiControl, 2:Choose, % App.Settings.TabHwnd, 4
	Gui, 4:Show, NA
	GuiControl, 4:Choose, % App.Settings.HotkeysSubTabHwnd, %SubTab%
	Hwnd := Hotkey_ID(Name)
	ControlFocus,, ahk_id %Hwnd%
	Sleep, 50
}

BlinkWindow(Hwnd) {
	Loop 6 {
		DllCall("ShowWindowAsync", "Ptr", Hwnd, "Int", Mod(A_Index, 2) ? 0 : 4)
		Sleep, 70
	}
	DllCall("ShowWindowAsync", "Ptr", Hwnd, "Int", 4)
}

SetScriptHotkeys(Enable, Values := "") {
	if !IsObject(Values)
		Values := GetScriptHotkeys()

	Hotkey, IfWinActive
	if IsHotkeyEnabled(Values.GetArea) {
		if Enable {
			obj := Func("GetScreenshot").Bind("Area")
			Hotkey, % Values.GetArea, % obj, On
		} else {
			Hotkey, % Values.GetArea, Off
		}
	}
	if IsHotkeyEnabled(Values.GetActiveWindow) {
		if Enable {
			obj := Func("GetScreenshot").Bind("ActiveWindow")
			Hotkey, % Values.GetActiveWindow, % obj, On
		} else {
			Hotkey, % Values.GetActiveWindow, Off
		}
	}
	if IsHotkeyEnabled(Values.GetScreen) {
		if Enable {
			obj := Func("GetScreenshot").Bind("Screen")
			Hotkey, % Values.GetScreen, % obj, On
		} else {
			Hotkey, % Values.GetScreen, Off
		}
	}
	if IsHotkeyEnabled(Values.ShowHideSelWindow) {
		if Enable
			Hotkey, % Values.ShowHideSelWindow, HideShow, On
		else
			Hotkey, % Values.ShowHideSelWindow, Off
	}
	if IsHotkeyEnabled(Values.SelWindowToCenter) {
		if Enable
			Hotkey, % Values.SelWindowToCenter, CenterSelectionWindow, On
		else
			Hotkey, % Values.SelWindowToCenter, Off
	}
	if IsHotkeyEnabled(Values.OpenOutputFolder) {
		if Enable
			Hotkey, % Values.OpenOutputFolder, OpenOutputDirectory, On
		else
			Hotkey, % Values.OpenOutputFolder, Off
	}
	if IsHotkeyEnabled(Values.SelectAreaOverlay) {
		if Enable {
			obj := Func("StartOverlaySelection").Bind("Arm")
			Hotkey, % Values.SelectAreaOverlay, % obj, On
		} else {
			Hotkey, % Values.SelectAreaOverlay, Off
		}
	}
	if IsHotkeyEnabled(Values.QuickSelectAreaOverlay) {
		if Enable {
			obj := Func("StartOverlaySelection").Bind("Quick")
			Hotkey, % Values.QuickSelectAreaOverlay, % obj, On
		} else {
			Hotkey, % Values.QuickSelectAreaOverlay, Off
		}
	}

	if IsHotkeyEnabled(Values.SelectPreview) {
		Hotkey, if, WinExist("ScreenShot ahk_class AutoHotkeyGUI")
		if Enable
			Hotkey, % Values.SelectPreview, FindHighlight, On
		else
			Hotkey, % Values.SelectPreview, Off
	}
	Hotkey, if
}

SetResizeHotkeyState(State) {
	Hotkey, IfWinActive
	Hotkey, LButton, WinResize, %State%
	Hotkey, if
}

Cursors1() {
	static
	SelectionHwnd := App.Selection.Hwnd
	S = 10
	MouseGetPos, X_M, Y_M, ID_Win
	for index, value in App.Windows {
		if (value.Hwnd = ID_Win) {
			if Cursor {
				RestoreCursors()
				SetResizeHotkeyState("Off")
				Cursor := ""
			}
			return
		}
	}
	WinGetPos, X, Y, W, H, ahk_id %SelectionHwnd%
	XW := X + W, YH := Y + H
	if ((X_M <= XW) && (X_M > XW - 2*S) && (Y_M <= YH) && (Y_M > YH - S))
					|| ((X_M <= XW) && (X_M > XW - S) && (Y_M <= YH) && (Y_M > YH - 2*S))
		Var := 1

	else if ((X_M < X + 2*S) && (X_M >= X) && (Y_M <= YH) && (Y_M > YH - S))
					|| ((X_M < X + S) && (X_M >= X) && (Y_M <= YH) && (Y_M > YH - 2*S))
		Var := 2

	else if ((X_M < X + 2*S) && (X_M >= X) && (Y_M < Y + S) && (Y_M >= Y))
					|| ((X_M < X + S) && (X_M >= X) && (Y_M < Y + 2*S) && (Y_M >= Y))
		Var := 3

	else if ((X_M <= XW ) && (X_M > XW - 2*S) && (Y_M < Y + S) && (Y_M >= Y))
					|| ((X_M <= XW ) && (X_M > XW - S) && (Y_M < Y + 2*S) && (Y_M >= Y))
		Var := 4

	else if (X_M <= XW) && (X_M > XW - S) && (Y_M <= YH - S) && (Y_M >= Y + S)
		Var := 5
	else if (X_M <= XW - S) && (X_M >= X + S) && (Y_M <= YH) && (Y_M > YH - S)
		Var := 6
	else if (X_M < X + S) && (X_M >= X) && (Y_M <= YH - S) && (Y_M >= Y + S)
		Var := 7
	else if (X_M <= XW - S) && (X_M >= X + S) && (Y_M < Y + S) && (Y_M >= Y)
		Var := 8
	else
		Var := ""

	if Var {
		SetResizeHotkeyState("On")
		if (Var = 1 || Var = 3) && (Cursor != "IDC_SIZENWSE")
			RestoreCursors(), SetSystemCursor("IDC_SIZENWSE"), Cursor := "IDC_SIZENWSE"

		if (Var = 2 || Var = 4) && (Cursor != "IDC_SIZENESW")
			RestoreCursors(), SetSystemCursor("IDC_SIZENESW"), Cursor := "IDC_SIZENESW"

		if (Var = 5 || Var = 7) && (Cursor != "IDC_SIZEWE")
			RestoreCursors(), SetSystemCursor("IDC_SIZEWE"), Cursor := "IDC_SIZEWE"

		if (Var = 6 || Var = 8) && (Cursor != "IDC_SIZENS")
			RestoreCursors(), SetSystemCursor("IDC_SIZENS"), Cursor := "IDC_SIZENS"
	} else {
		SetResizeHotkeyState("Off")
		RestoreCursors(), Cursor := ""
	}
	return Var
}

Markers1() {
	SelectionHwnd := App.Selection.Hwnd
	MouseGetPos, X_M, Y_M, ID_Win
	for index, value in App.Windows {
		if (value.Hwnd = ID_Win) {
			SetResizeHotkeyState("Off")
			Loop 8
				GuiControl, Hide, static%a_index%
			return
		}
	}
	WinGetPos, X, Y, W, H, ahk_id %SelectionHwnd%
	XW := X + W, YH := Y + H

	if (X_M <= XW + 20) && (X_M >= XW - 10) && (Y_M <= YH + 20) && (Y_M >= YH - 10)
		Var := 1

	else if (X_M <= X + 10) && (X_M >= X - 20) && (Y_M <= YH + 20) && (Y_M >= YH - 10)
		Var := 2

	else if (X_M <= X + 10) && (X_M >= X - 20) && (Y_M <= Y + 10) && (Y_M >= Y - 20)
		Var := 3

	else if (X_M <= XW + 20) && (X_M >= XW - 10) && (Y_M <= Y + 10) && (Y_M >= Y - 20)
		Var := 4

	else if (X_M <= XW + 20) && (X_M >= XW - 10) && (Y_M < YH - 10) && (Y_M > Y + 10)
		Var := 5

	else if (X_M < XW - 10) && (X_M > X + 10) && (Y_M <= YH + 20) && (Y_M >= YH - 10)
		Var := 6

	else if (X_M <= X + 10) && (X_M >= X - 20) && (Y_M < YH - 10) && (Y_M > Y + 10)
		Var := 7

	else if (X_M < XW - 10) && (X_M > X + 10) && (Y_M <= Y + 10) && (Y_M >= Y - 20)
		Var := 8

	else Var := ""

	if Var {
		SetResizeHotkeyState("On")
		GuiControl, Show, static%Var%
		Loop 8 {
			if (a_index != Var)
				GuiControl, Hide, static%a_index%
		}
	} else {
		SetResizeHotkeyState("Off")
		Loop 8 {
			GuiControl, Hide, static%a_index%
		}
	}
	return Var
}

WinResize() {
	SelectionHwnd := App.Selection.Hwnd
	ResizeVar := App.Selection.ResizeHandle
	SetResizePointerTimer("Off")
	MouseGetPos, X_M_Old, Y_M_Old
	WinGetPos, X, Y, W, H, ahk_id %SelectionHwnd%
	while GetKeyState("LButton", "P") {
		MouseGetPos, X_M, Y_M
		dX := X_M - X_M_Old, dY := Y_M - Y_M_Old
		IfEqual, ResizeVar, 1, WinMove, ahk_id %SelectionHwnd%,,,, W + dX, H + dY
		IfEqual, ResizeVar, 2, WinMove, ahk_id %SelectionHwnd%,, X + dX,, W - dX, H + dY
		IfEqual, ResizeVar, 3, WinMove, ahk_id %SelectionHwnd%,, X + dX, Y + dY, W - dX, H - dY
		IfEqual, ResizeVar, 4, WinMove, ahk_id %SelectionHwnd%,,, Y + dY, W + dX, H - dY
		IfEqual, ResizeVar, 5, WinMove, ahk_id %SelectionHwnd%,,,, W + dX
		IfEqual, ResizeVar, 6, WinMove, ahk_id %SelectionHwnd%,,,,, H + dY
		IfEqual, ResizeVar, 7, WinMove, ahk_id %SelectionHwnd%,, X + dX,, W - dX
		IfEqual, ResizeVar, 8, WinMove, ahk_id %SelectionHwnd%,,, Y + dY,, H - dY
		Sleep, 10
	}
	SetResizePointerTimer("On")
}

IsSelectionWindowActive() {
	SelectionHwnd := App.Selection.Hwnd
	return (SelectionHwnd && WinActive("ahk_id " SelectionHwnd))
}

NudgeSelectionEdge(Edge, Delta) {
	static MinSize := 1

	SelectionHwnd := App.Selection.Hwnd
	if !WinExist("ahk_id " SelectionHwnd)
		return

	WinGetPos, X, Y, W, H, ahk_id %SelectionHwnd%
	if (Edge = "Left") {
		if (W - Delta < MinSize)
			return
		WinMove, ahk_id %SelectionHwnd%,, X + Delta, Y, W - Delta, H
	} else if (Edge = "Top") {
		if (H - Delta < MinSize)
			return
		WinMove, ahk_id %SelectionHwnd%,, X, Y + Delta, W, H - Delta
	} else if (Edge = "Right") {
		if (W + Delta < MinSize)
			return
		WinMove, ahk_id %SelectionHwnd%,, X, Y, W + Delta, H
	} else if (Edge = "Bottom") {
		if (H + Delta < MinSize)
			return
		WinMove, ahk_id %SelectionHwnd%,, X, Y, W, H + Delta
	}
}

NormalizeLoadedSettings() {
	if !IsIntegerSetting(App.Config.ARGB)
		App.Config.ARGB := 0x82FFC700

	if !RegExMatch(App.Config.Output, "^(File|Clip|Imgbb)+$")
		App.Config.Output := "File"

	if !RegExMatch(App.Config.Ext, "^(png|jpg|bmp|tif|gif)$")
		App.Config.Ext := "png"

	if (!IsIntegerSetting(App.Config.JPEGQuality) || App.Config.JPEGQuality < 50 || App.Config.JPEGQuality > 100)
		App.Config.JPEGQuality := 100

	if (App.Config.OutDirectory = "" || App.Config.OutDirectory = "OutDirectory")
		App.Config.OutDirectory := A_ScriptDir

	if !IsBooleanSetting(App.Config.CaptureCursor)
		App.Config.CaptureCursor := 0
	if !IsBooleanSetting(App.Config.ShowPreview)
		App.Config.ShowPreview := 1
	if !IsBooleanSetting(App.Config.Notify)
		App.Config.Notify := 1

	App.Config.ResizePointers := NormalizeResizePointersValue(App.Config.ResizePointers)

	if (!IsIntegerSetting(App.Config.InterpolationMode) || App.Config.InterpolationMode < 1 || App.Config.InterpolationMode > 8)
		App.Config.InterpolationMode := 3
}

NormalizeResizePointersValue(Value) {
	return Value = "Markers" ? "Markers" : "Cursors"
}

SetResizePointerTimer(State, Value := "") {
	TimerName := NormalizeResizePointersValue(Value = "" ? App.Config.ResizePointers : Value)
	SetTimer, %TimerName%, %State%
}

Cursors() {
	UpdateResizePointerHover(A_ThisFunc)
}

Markers() {
	UpdateResizePointerHover(A_ThisFunc)
}

IsIntegerSetting(Value) {
	return RegExMatch(Value, "i)^\s*(?:0x[0-9a-f]+|\d+)\s*$")
}

IsBooleanSetting(Value) {
	return Value = 0 || Value = 1
}

IniReadConfigSect(Section, params*) {
; Читает секцию Section ini-файла в App.Config
	ConfigNames := [ "ARGB", "Output", "Ext", "JPEGQuality", "OutDirectory", "CaptureCursor"
		           , "ShowPreview", "Notify", "ResizePointers", "InterpolationMode" ]
	IniReadObjectSect(Section, App.Config, ConfigNames, params*)
}

IniReadHotkeysSect(Section, params*) {
; Читает секцию Section ini-файла в App.Hotkeys.
	if !IsObject(App.Hotkeys)
		App.Hotkeys := {}
	IniReadObjectSect(Section, App.Hotkeys, ScreenCatcherHotkeyNames(), params*)
}

IniReadObjectSect(Section, Target, AllowedNames, params*) {
; Читает секцию Section ini-файла в объект Target.
	IniName := IniFilePath()
	for index, param in params {
		if Mod(index, 3) = 1
			Key := param
		else if Mod(index, 3) = 2
			Name := param
		else {
			IniRead, Value, % IniName, % Section, % Key, % param
			SetObjectValue(Target, AllowedNames, Name, Value)
		}
	}
}

SetObjectValue(Target, AllowedNames, Name, Value) {
	for index, AllowedName in AllowedNames {
		if (Name = AllowedName) {
			Target[AllowedName] := Value
			return
		}
	}
}

IniWriteSect(Section, params*) {
; Пишет секцию Section ini-файла в директории скрипта.
    IniName := IniFilePath()
    for index, param in params {
		if Mod(index, 2)
			Key := param
		else
			IniWrite, % param, % IniName, % Section, % Key
	}
}

IniFilePath() {
	return RegExReplace(A_ScriptFullPath, "(.*)\..*", "$1.ini")
}

Melt(hWnd, Trans, Appear, N = 20) {
	WinShow, ahk_id %hWnd%
	while (i := A_Index * N) < Trans {
		WinSet, Transparent, % Appear ? i : Trans - i, ahk_id %hWnd%
		Sleep, 10
	}
	if Appear
		WinSet, Transparent, % Trans, ahk_id %hWnd%
	else
		WinHide, ahk_id %hWnd%
}

SetSystemCursor(IDC) {
	static IDC_SIZENWSE := 32642, IDC_SIZENESW := 32643, IDC_SIZEWE := 32644
		 , IDC_SIZENS   := 32645, IDC_ARROW    := 32512
		 , sys_cursors  := [32512,32513,32514,32516,32642,32643,32644,32645,32646,32648,32649,32650]

	hCursor := DllCall("LoadCursor", "UInt", 0, "Int", %IDC%)
	for k, v in sys_cursors {
		hCopy := DllCall("CopyImage", "Ptr", hCursor, "UInt", 2, "Int", 0, "Int", 0, "UInt", 0)
		DllCall("SetSystemCursor", "UInt", hCopy, "Int", v)
	}
}

RestoreCursors() {
    DllCall("SystemParametersInfo", "UInt", SPI_SETCURSORS:=0x57, "UInt", 0, "UInt", 0, "UInt", 0)
}

SetColorToControl(hwnd, Color) {	; окрашивает static-контрол со стилем SS_BITMAP = 0xE в цвет Color
	WinGetPos,,, w, h, ahk_id %hwnd%

	DllCall("gdiplus\GdipCreateSolidFill", "UInt", 0xFF000000|Color, "Ptr*", pBrush)
	DllCall("gdiplus\GdipCreateBitmapFromScan0", "Int", w, "Int", h, "Int", 0, "Int", 0x26200A, "Ptr", 0, "Ptr*", pBitmap)
	DllCall("gdiplus\GdipGetImageGraphicsContext", "Ptr", pBitmap, "Ptr*", G)
	DllCall("gdiplus\GdipFillRectangle", "Ptr", G, "Ptr", pBrush, "Float", 0, "Float", 0, "Float", w, "Float", h)
	DllCall("gdiplus\GdipCreateHBITMAPFromBitmap", "Ptr", pBitmap, "Ptr*", hBitmap, "Int", 0xFFFFFFFF)
	SendMessage, STM_SETIMAGE := 0x172,, hBitmap,, ahk_id %hwnd%
	DllCall("DeleteObject", "Ptr", ErrorLevel)
	DllCall("gdiplus\GdipDeleteBrush", "Ptr", pBrush)
	DllCall("gdiplus\GdipDeleteGraphics", "Ptr", G)
	DllCall("gdiplus\GdipDisposeImage", "Ptr", pBitmap)
	DllCall("DeleteObject", "Ptr", hBitmap)
}

DDLCreate(N) {
	Loop % N
		String .= A_Index-1 "|"
	return SubStr(String, 1, -1)
}

WM_LBUTTONDOWN(wParam, lParam, msg, hwnd) {
	if IsOverlaySelectionHwnd(hwnd)
		return
	if (A_Gui = 1 || A_Gui > 9) {
		if (A_Gui > 9) {
			App.Menu.CancelPreviewIntroHwnd := hwnd
			HidePreviewHighlight()
		}
		PostMessage, WM_NCLBUTTONDOWN := 0xA1, HTCAPTION := 2,,, % "ahk_id " hwnd
	}

	else if (A_Gui = 2 && WhichPageOfTab(App.Settings.TabHwnd) = 4)
	{
		MouseGetPos,,,, Control
		if InStr(Control, "ComboBox")
		{
			GuiControlGet, OutputVar, 3:Enabled, % Control
			if OutputVar
				return
			else
				GuiControl, 3:Focus, TextT
		}
		else
			GuiControl, 3:Focus, TextT
	}
}

WM_LBUTTONDBLCLK(wParam, lParam, msg, hwnd) {
	if IsOverlaySelectionHwnd(hwnd)
		return
	(A_Gui = 1) && GetScreenshot("Area")
}

WM_RBUTTONDOWN(wParam, lParam, msg, hwnd) {
	if IsOverlaySelectionHwnd(hwnd)
		return
	if (A_Gui < 10 || A_Gui = "Imgbb")
		return
	App.Menu.CurrentPreviewGui := A_Gui
	Menu, % App.Windows[A_Gui].Scale = 1 ? "ScreenShotMenu" : "ScreenShotMenu2", Show
}

AHK_NOTIFYICON(wp, lp) {
	static WM_LBUTTONDOWN := 0x201
	(lp = WM_LBUTTONDOWN) && ToggleSelectionWindow()
}

WhichPageOfTab(SettingsTabHwnd) {
	ControlGet, NTab, Tab,,, ahk_id %SettingsTabHwnd%
	return NTab
}

GetControlFocus(NGui) {
	GuiControlGet, Focus, %NGui%:Focus
	return Focus
}

GetOverlaySelection() {
	if !IsObject(App.Selection.Overlay) {
		gap := 5
		labelSpecs := [{style: {fontStyle: 1}
					  , provider: Func("OverlayTopLabelProvider").Bind(gap)}
					 , {style: {fontStyle: 1}
					  , provider: Func("OverlayBottomLabelProvider").Bind(gap)}]
		armedStyle := {fontStyle: 1, offsetX: 12, offsetY: 12}
		App.Selection.Overlay := new OverlaySelection(2, 0xFFAA00, labelSpecs, armedStyle)
		Gui, 1:Default
	}
	return App.Selection.Overlay
}

StartOverlaySelection(Mode) {
	Overlay := GetOverlaySelection()
	Callback := Func("CaptureOverlaySelection")
	if (Mode = "Quick")
		Overlay.Quick(Callback)
	else
		Overlay.Arm(Callback)
}

CaptureOverlaySelection(Rect) {
	if (Rect.w < 1 || Rect.h < 1)
		return
	GetScreenshot("Area", Rect)
}

OverlayTopLabelProvider(Gap, Context) {
	Rect := Context.r
	return {text: Rect.x . ", " . Rect.y . "  " . Rect.w . "x" . Rect.h
		  , ax: Rect.x
		  , ay: Rect.y - Context.t - Round(Gap * Context.scale)
		  , side: "top"}
}

OverlayBottomLabelProvider(Gap, Context) {
	Rect := Context.r
	return {text: (Rect.x + Rect.w) . ", " . (Rect.y + Rect.h)
		  , ax: Rect.x + Rect.w
		  , ay: Rect.y + Rect.h + Context.t + Round(Gap * Context.scale)
		  , side: "bottom"}
}

IsOverlaySelectionState(State) {
	return IsObject(App.Selection.Overlay) && App.Selection.Overlay.state = State
}

BeginOverlaySelectionDrag() {
	if IsObject(App.Selection.Overlay)
		App.Selection.Overlay.BeginDrag()
}

CancelOverlaySelection() {
	if IsObject(App.Selection.Overlay)
		App.Selection.Overlay.Cancel()
}

FinishOverlaySelection() {
	if IsObject(App.Selection.Overlay)
		App.Selection.Overlay.Finish()
}

GetScreenshot(Area, SelectionRect := "") {
	SelectionHwnd := App.Selection.Hwnd
	SRCCOPY := 0x00CC0020, CAPTUREBLT := 0x40000000
	Critical
	if (Area = "Area") {
		IfWinExist, ahk_id %SelectionHwnd%
		{
			Vis = 1
			WinHide	; Melt(SelectionHwnd, App.Config.ARGB>>24, 0, 50)
		}
		if IsObject(SelectionRect) {
			X := SelectionRect.x
			Y := SelectionRect.y
			W := SelectionRect.w
			H := SelectionRect.h
		} else {
			DetectHiddenWindows, On
			WinGetPos, X, Y, W, H, ahk_id %SelectionHwnd%
		}
		Rect := X "|" Y "|" W "|" H
		pBitmap := BitmapFromScreen(Rect, App.Config.CaptureCursor, SRCCOPY|CAPTUREBLT)
		if Vis
		{
			Sleep, 50
			WinShow	; Melt(SelectionHwnd, App.Config.ARGB>>24, 1, 50)
		}
	} else if (Area = "ActiveWindow") {
		WinGet, hwnd, ID, A
		if !GetVisibleWindowRect(hwnd, X, Y, W, H)
			WinGetPos, X, Y, W, H, ahk_id %hwnd%
		pBitmap := BitmapFromScreen(X "|" Y "|" W "|" H, App.Config.CaptureCursor, SRCCOPY|CAPTUREBLT)
	} else {
		X := Y := 0
		W := A_ScreenWidth
		H := A_ScreenHeight
		pBitmap := BitmapFromScreen(0, App.Config.CaptureCursor, SRCCOPY|CAPTUREBLT)
	}
	Critical, Off   ; capture is done; let the message queue flow for preview/notification

	Time := A_Year "." A_MM  "." A_DD "-" A_Hour "." A_Min "." A_Sec "." SubStr(A_MSec, 1, 1)

	if (App.Config.ShowPreview) {
		ShowPreview(pBitmap, Time, X, Y, W, H)
	} else {
		SaveScreenshot(pBitmap, Time)
	}
}

BitmapFromHWND(hwnd) {
	WinGetPos,,, Width, Height, ahk_id %hwnd%
	hbm := CreateDIBSection(Width, Height)
	hdc := DllCall("CreateCompatibleDC", "Ptr", 0)
	obm := DllCall("SelectObject", "Ptr", hdc, "Ptr", hbm)
	DllCall("PrintWindow", "Ptr", hwnd, "Ptr", hdc, "UInt", PW_RENDERFULLCONTENT := 2)
	DllCall("gdiplus\GdipCreateBitmapFromHBITMAP", "Ptr", hbm, "Ptr", 0, "Ptr*", pBitmap)
	DllCall("SelectObject", "Ptr", hdc, "Ptr", obm)
	DllCall("DeleteObject", "Ptr", hbm)
	DllCall("DeleteDC", "Ptr", hdc)
	return pBitmap
}

GetBitmapFromWindow(hwnd) {
	WinGetPos,,, W, H, ahk_id %hwnd%
	hWDC := DllCall("GetWindowDC", "Ptr", hwnd, "Ptr")
	hdc := DllCall("CreateCompatibleDC", "Ptr", hWDC, "Ptr")
	hbm := DllCall("CreateCompatibleBitmap", "Ptr", hWDC, "Int", W, "Int", H)
	obm := DllCall("SelectObject", "Ptr", hdc, "Ptr", hbm)
	DllCall("BitBlt", "Ptr", hdc, "Int", 0, "Int", 0, "Int", W, "Int", H, "Ptr", hWDC, "Int", 0, "Int", 0, "UInt", 0x00CC0020)
	DllCall("ReleaseDC", "Ptr", hwnd, "Ptr", hWDC)
	DllCall("gdiplus\GdipCreateBitmapFromHBITMAP", "Ptr", hbm, "Ptr", 0, "Ptr*", pBitmap)
	DllCall("SelectObject", "Ptr", hdc, "Ptr", obm)
	DllCall("DeleteObject", "Ptr", hbm)
	DllCall("DeleteDC", "Ptr", hdc)
	return pBitmap
}

ShowPreview(pBitmap, Time, X, Y, W, H) {
	static WS_EX_LAYERED := 0x80000
	SelectionHwnd := App.Selection.Hwnd

	while App.Windows[i := A_Index+9]
		continue

	Gui, %i%: -Caption +E%WS_EX_LAYERED% +LastFound +AlwaysOnTop +ToolWindow +Owner
	WinGet, PreviewHwnd
	Gui, %i%: Show, NA, ScreenShot

	hbm := CreateDIBSection(W, H)
	hdc := DllCall("CreateCompatibleDC", "Ptr", 0)
	obm := DllCall("SelectObject", "Ptr", hdc, "Ptr", hbm)
	DllCall("gdiplus\GdipCreateFromHDC", "Ptr", hdc, "Ptr*", G)
	DrawImage(G, pBitmap, 0, 0, W, H, 0, 0, W, H)

	UpdateLayeredWindow(PreviewHwnd, hdc, X, Y, W, H)
	WinActivate, ahk_id %PreviewHwnd%

	App.Windows[i] := Object("Hwnd", PreviewHwnd, "Time", Time, "pBM", pBitmap)

	DllCall("SelectObject", "Ptr", hdc, "Ptr", obm)
	DllCall("DeleteObject", "Ptr", hbm)
	DllCall("DeleteDC", "Ptr", hdc), DllCall("gdiplus\GdipDeleteGraphics", "Ptr", G)

	SetWinDelay, 10
	Loop 10 {
		if (App.Menu.CancelPreviewIntroHwnd = PreviewHwnd)
			break
		WinMove, ahk_id %PreviewHwnd%,, X+A_Index, Y-A_Index
	}

	DetectHiddenWindows, Off
	if !WinExist("ahk_id " SelectionHwnd)
		ShowPreviewHighlight(PreviewHwnd)
	if (App.Menu.CancelPreviewIntroHwnd = PreviewHwnd)
		App.Menu.CancelPreviewIntroHwnd := ""
}

ShowPreviewHighlight(PreviewHwnd) {
	Critical
	if (App.Menu.CancelPreviewIntroHwnd = PreviewHwnd) {
		Critical, Off
		return
	}
	Highlight(PreviewHwnd)
	Critical, Off
	Sleep, 300
	HidePreviewHighlight()
}

Highlight(TargetHwnd) {
	HidePreviewHighlight()
	WinActivate, ahk_id %TargetHwnd%
	; WS_EX_LAYERED := 0x80000, WS_EX_TRANSPARENT := 0x20
	Gui, 5:-Caption +E0x80020 +LastFound +AlwaysOnTop +ToolWindow +Owner
	WinGet, HighlightHwnd
	App.Menu.HighlightHwnd := HighlightHwnd
	Gui, 5:Show, NA
	WinGetPos, X, Y, W, H, ahk_id %TargetHwnd%
	hbm := CreateDIBSection(W, H)
	hdc := DllCall("CreateCompatibleDC", "Ptr", 0)
	obm := DllCall("SelectObject", "Ptr", hdc, "Ptr", hbm)
	DllCall("gdiplus\GdipCreateFromHDC", "Ptr", hdc, "Ptr*", G)

	DllCall("gdiplus\GdipCreateSolidFill", "UInt", 0xffffaa00, "Ptr*", pBrush)
	TH := 5	; толщина линии подсветки
	Points := "0,0|" W ",0|" W "," H "|0," H "|0," TH "|" TH "," 
		. TH "|" TH "," H - TH "|" W - TH "," H - TH "|" W - TH "," TH "|0," TH
	FillPolygon(G, pBrush, Points)
	DllCall("gdiplus\GdipDeleteBrush", "Ptr", pBrush)

	UpdateLayeredWindow(HighlightHwnd, hdc, X, Y, W, H)

	DllCall("SelectObject", "Ptr", hdc, "Ptr", obm)
	DllCall("DeleteObject", "Ptr", hbm), DllCall("DeleteDC", "Ptr", hdc)
	DllCall("gdiplus\GdipDeleteGraphics", "Ptr", G)
}

HidePreviewHighlight() {
	HighlightHwnd := App.Menu.HighlightHwnd
	if (HighlightHwnd && WinExist("ahk_id " HighlightHwnd))
		Gui, 5:Destroy
	App.Menu.HighlightHwnd := ""
}

FindHighlight() {
	static CurrentScr

	if !CurrentScr
		CurrentScr := App.Windows.MaxIndex()
	else {
		while !App.Windows[CurrentScr := CurrentScr = 10 ? App.Windows.MaxIndex() : CurrentScr - 1]
			continue
	}
	Highlight(App.Windows[CurrentScr].Hwnd)
	KeyWait, Space
	HidePreviewHighlight()
}

SaveScreenshot(pBitmap, OutFileName, OutputOverride := "") {
	Output := OutputOverride = "" ? App.Config.Output : OutputOverride
	OutDirectory := App.Config.OutDirectory
	Ext := App.Config.Ext
	JPEGQuality := App.Config.JPEGQuality
	ImgbbSent := false
	MissingImgbbClientID := false

	if (File := InStr(Output, "File")) {
		Critical
		IfNotExist, % OutDirectory
		{
			FileCreateDir, % OutDirectory
			if ErrorLevel {
				File := ""
				MsgBox, 48, Невозможно создать папку
					, Невозможно создать папку вывода.`nОшибка %A_LastError%
			}
		}

		if (Result := SaveBitmap(pBitmap, OutDirectory "\" OutFileName "." Ext, JPEGQuality)) {
			File := ""
			Errors := { 2: "Could not get a list of encoders on system"
						 , 3: "Could not find matching encoder for specified file format"
						 , 4: "Could not save file to disk" }
			MsgBox, 48, Ошибка записи в файл, % Errors[-Result]
		}
	}
	if Clip := InStr(Output, "Clip")
		SetBitmapToClipboard(pBitmap)
	if InStr(Output, "Imgbb") {
		ClientID := EnsureImgbbClientId()
		if (ClientID = "")
			MissingImgbbClientID := true
		else {
			SendImageToImgbb(pBitmap, ClientID)
			ImgbbSent := true
		}
	}
	if (App.Config.Notify) {
		if File && Clip && ImgbbSent
			NotifyText := "Скриншот сохранён в файл,`nпомещён в буфер обмена`nи отправлен на imgbb.com"
		else {
			NotifyText := "Скриншот "
			if File
				NotifyText .= (NotifyText = "Скриншот " ? "" : "`nи ") . "сохранён в файл"
			if Clip
				NotifyText .= (NotifyText = "Скриншот " ? "" : "`nи ") . "помещён в буфер обмена"
			if ImgbbSent
				NotifyText .= (NotifyText = "Скриншот " ? "" : "`nи ") . "отправлен на imgbb.com"
			if MissingImgbbClientID {
				if (NotifyText = "Скриншот ")
					NotifyText .= "не отправлен на Imgbb!`nВпишите ClientID в ScreenCatcher.ini"
				else
					NotifyText .= "`nно не отправлен на Imgbb"
			}
		}
		if (NotifyText = "Скриншот ")
			NotifyText := MissingImgbbClientID
				? "Скриншот не отправлен на Imgbb!`nВпишите ClientID в ScreenCatcher.ini"
				: "Скриншот не сохранён!`nУкажите в настройках во вкладке ""Вывод""`nвариант сохранения скриншота!"
		new ToolTip({ text: NotifyText, FontSize: 14, FontName: "calibri", TrayTip: true
							, TimeOut: -3500, BackColor: 0x0055aa, TextColor: "white"
							, Margin: [10, 5, 10, 5] })
	}
	DllCall("gdiplus\GdipDisposeImage", "Ptr", pBitmap)
}

SendImageToImgbb(pBitmap, apiKey) {
	Ext := App.Config.Ext
	JPEGQuality := App.Config.JPEGQuality
	buff := Ext
	if ( (size := SaveBitmap(pBitmap, buff, JPEGQuality, 1)) < 0 ) {
		Errors := { 2: "Could not get a list of encoders on system"
				  , 3: "Could not find matching encoder for specified file format"
				  , 4: "Не удалось сохранить битмап в буфер" }
		MsgBox, 48, Ошибка записи в буфер, % Errors[-size]
		return
	}
    strBase64 := EncodeDecodeURI(CryptBinaryToStringBASE64(&buff, size, 1))
    http := ComObjCreate("WinHttp.WinHttpRequest.5.1")
    http.open("POST", "https://api.imgbb.com/1/upload", true)
    http.SetRequestHeader("Content-Type", "application/x-www-form-urlencoded")
    body := "key=" . apiKey . "&image=" . strBase64
    http.send(body)
    http.WaitForResponse()
    if (http.status != 200)
       throw "failed to upload image. Status: " . http.status
	responsetext := http.responsetext
    RegExMatch(responsetext, """url"":""(.*?)""", match)
    link := StrReplace(match1, "\")
	Gui, 5: Default
	try Gui, Destroy
	Gui, Font, s9
	Gui, Add, Edit, % "w250 h" . (link ? 24 : 120), % link ? link : responsetext
	Gui, Font
	Gui, Add, Button, x+-80 y+7 w80 h24 gCopyResponse Default, Copy
	GuiControl, Focus, Button1
	Gui, Show,, Imgbb.com
	VarSetCapacity(strBase64, 0), VarSetCapacity(buff, 0)
}

EncodeDecodeURI(str, encode := true, component := true) {
    static document := "", JS := ""
    if !document {
        document := ComObjCreate("htmlfile")
        document.write("<meta http-equiv=""X-UA-Compatible"" content=""IE=9"">")
        JS := document.parentWindow
        (document.documentMode < 9 && JS.execScript())
    }
    return JS[(encode ? "en" : "de") . "codeURI" . (component ? "Component" : "")](str)
}

CopyResponse() {
	GuiControlGet, Clipboard, 5:, Edit1
	Gui, 5: Destroy
}

WM_SHOWWINDOW(wp, lp, msg, hwnd) {
	if IsOverlaySelectionHwnd(hwnd)
		return
	if (A_Gui < 10 || wp || A_Gui = "Imgbb")	; окно показывается — wp = true, скрывается — wp = false
		return

	Gui, %A_Gui%:Destroy
	DllCall("gdiplus\GdipDisposeImage", "Ptr", App.Windows[A_Gui].pBM)
	App.Windows.Remove(A_Gui, "")
}

WM_COMMAND(info, wp, lp) {
	static EN_SETFOCUS := 0x100, EN_KILLFOCUS := 0x200
	
	notify := wp >> 16
	if !(notify = EN_SETFOCUS || notify = EN_KILLFOCUS)
		return
	
	for k, v in info {
		if (v = lp) {
			( notify = EN_SETFOCUS && DllCall("HideCaret", "Ptr", v) )
			SetStaticColor(v, notify = EN_SETFOCUS ? 0xFECC53 : 0xFFFFFF, 0)
		}
	}
}

WM_SETCURSOR(info, wp) {
   static hCursor, OCR_NORMAL := 32512
   ( !hCursor && hCursor := LoadCursor(OCR_NORMAL) )
	for k, v in info {
		if (v = wp)
			return DllCall("SetCursor", "Ptr", hCursor)
	}
}

WM_OVERLAY_SETCURSOR(wParam, lParam, msg, hwnd) {
	static hCross := DllCall("LoadCursor", "Ptr", 0, "Ptr", 32515, "Ptr")
	if !IsOverlaySelectionHwnd(hwnd)
		return
	DllCall("SetCursor", "Ptr", hCross)
	return true
}

IsOverlaySelectionHwnd(hwnd) {
	return hwnd && IsObject(App.Selection.Overlay)
		&& IsObject(App.Selection.Overlay.overlay)
		&& hwnd = App.Selection.Overlay.overlay.hwnd
}

LoadCursor(cursorId) {
   static IMAGE_CURSOR := 2, LR_DEFAULTSIZE := 0x40, LR_SHARED := 0x8000
   return DllCall("LoadImage", "Ptr", 0
                             , "UInt", cursorId
                             , "UInt", IMAGE_CURSOR
                             , "Int", 0, "Int", 0
                             , "UInt", LR_DEFAULTSIZE|LR_SHARED, "Ptr")
}

WM_ESC() {
	Gui, %A_Gui%:Cancel
}

WM_WHEEL(wp, lp, msg, hwnd) {
	static PrevTime = 0
	Critical

	App.Windows[A_Gui].Scale := 1		; значит, размер скриншота изменён

	pBitmap := App.Windows[A_Gui].pBM
	GetImageDimensions(pBitmap, WidthBM, HeightBM)
	RatioBM := WidthBM/HeightBM
	SquareBM := WidthBM*HeightBM

	WinGetPos, X, Y, W, H, A
	DeltaW := Round(W/(!wp ? 10 : 11))
	CtrlState := GetKeyState("Ctrl", "P")
	DeltaW := !wp ? (CtrlState ? 1 : DeltaW) : -(CtrlState ? 1 : DeltaW)
	ResultW := W + DeltaW
	ResultH := Round(ResultW/RatioBM)
	ResultX := X - (CtrlState ? 0 : Round(DeltaW/2))
	ResultY := Y - (CtrlState ? 0 : Round((ResultH - H)/2))
	SquareWin := ResultW*ResultH
	if (!wp && SquareWin > 13000000) || (wp && SquareWin < 1000 && SquareWin < SquareBM) {
		if (A_TickCount - PrevTime > 200) {
			SoundBeep
			PrevTime := A_TickCount
		}
		return
	}

	hbm := CreateDIBSection(ResultW, ResultH)
	hdc := DllCall("CreateCompatibleDC", "Ptr", 0)
	obm := DllCall("SelectObject", "Ptr", hdc, "Ptr", hbm)
	DllCall("gdiplus\GdipCreateFromHDC", "Ptr", hdc, "Ptr*", G)
	DllCall("gdiplus\GdipSetInterpolationMode", "Ptr", G, "Int", App.Config.InterpolationMode-1)
	DrawImage(G, pBitmap, 0, 0, ResultW, ResultH, 0, 0, WidthBM, HeightBM)
	UpdateLayeredWindow(hwnd, hdc, ResultX, ResultY, ResultW, ResultH)

	DllCall("SelectObject", "Ptr", hdc, "Ptr", obm)
	DllCall("DeleteObject", "Ptr", hbm), DllCall("DeleteDC", "Ptr", hdc), DllCall("gdiplus\GdipDeleteGraphics", "Ptr", G)
}

GetImageDimensions(pBitmap, ByRef Width, ByRef Height) {
	DllCall("gdiplus\GdipGetImageWidth", "Ptr", pBitmap, "UInt*", Width)
	DllCall("gdiplus\GdipGetImageHeight", "Ptr", pBitmap, "UInt*", Height)
}

GetVisibleWindowRect(hwnd, ByRef X, ByRef Y, ByRef W, ByRef H) {
	static DWMWA_EXTENDED_FRAME_BOUNDS := 9

	VarSetCapacity(rect, 16, 0)
	if DllCall("dwmapi\DwmGetWindowAttribute", "Ptr", hwnd, "UInt", DWMWA_EXTENDED_FRAME_BOUNDS
													, "Ptr", &rect, "UInt", 16)
		return false

	left   := NumGet(rect,  0, "Int")
	top    := NumGet(rect,  4, "Int")
	right  := NumGet(rect,  8, "Int")
	bottom := NumGet(rect, 12, "Int")
	if (right <= left || bottom <= top)
		return false

	X := left, Y := top, W := right - left, H := bottom - top
	return true
}

FillPolygon(pGraphics, pBrush, Points, FillMode=0) {
	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)
}

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

	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", 0, "Ptr", 0, "Ptr", 0)
	return E
}

BitmapFromScreen(Screen, Cursor, Raster="") {
	if (Screen = 0) {
		Sysget, x, 76
		Sysget, y, 77
		Sysget, w, 78
		Sysget, h, 79
	} else {
		StringSplit, S, Screen, |
		x := S1, y := S2, w := S3, h := S4
	}
	chdc := DllCall("CreateCompatibleDC", "Ptr", 0, "Ptr")
	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), NumPut(32, bi, 14, "UShort")
	hbm := DllCall("CreateDIBSection", "Ptr" , chdc, "Ptr" , &bi, "UInt" , 0, "Ptr*", 0, "Ptr" , 0, "UInt" , 0, "Ptr")
	obm := DllCall("SelectObject", "Ptr", chdc, "Ptr", hbm, "Ptr")
	hhdc := DllCall("GetDC", "Ptr", 0, "Ptr")
	DllCall("BitBlt", "Ptr", chdc, "Int", 0, "Int", 0, "Int", w, "Int", h, "Ptr", hhdc, "Int", x, "Int", y, "UInt", Raster)
	DllCall("ReleaseDC", "Ptr", 0, "Ptr", hhdc)
	( Cursor && CaptureCursor(chdc, x, y) )
	DllCall("gdiplus\GdipCreateBitmapFromHBITMAP", "Ptr", hbm, "Ptr", 0, "Ptr*", pBitmap)
	DllCall("SelectObject", "Ptr", chdc, "Ptr", obm, "Ptr")
	DllCall("DeleteObject", "Ptr", hbm)
	DllCall("DeleteDC", "Ptr", hhdc)
	DllCall("DeleteDC", "Ptr", chdc)
	return pBitmap
}

CaptureCursor(hDC, x, y) {
	VarSetCapacity(CURSORINFO, szCI := 4*2 + A_PtrSize + 8, 0)
	NumPut(szCI, CURSORINFO)
	DllCall("GetCursorInfo", "Ptr", &CURSORINFO)
	bShow   := NumGet(CURSORINFO, 4, "UInt")
	hCursor := NumGet(CURSORINFO, 4*2)
	xCursor := NumGet(CURSORINFO, 4*2 + A_PtrSize, "Int")
	yCursor := NumGet(CURSORINFO, 4*2 + A_PtrSize + 4, "Int")

	if bShow && hCursor := DllCall("CopyIcon", "Ptr", hCursor, "Ptr") {
		VarSetCapacity(ICONINFO, 4*2 + A_PtrSize*3, 0)
		DllCall("GetIconInfo", "Ptr", hCursor, "Ptr", &ICONINFO)
		bIcon    := NumGet(ICONINFO, "UInt")
		xHotspot := NumGet(ICONINFO, 4, "UInt")
		yHotspot := NumGet(ICONINFO, 4*2, "UInt")
		hBMMask  := NumGet(ICONINFO, 4*2 + A_PtrSize)
		hBMColor := NumGet(ICONINFO, 4*2 + A_PtrSize*2)

		DllCall("DrawIcon", "Ptr", hDC, "Int", xCursor - xHotspot - x, "Int", yCursor - yHotspot - y, "Ptr", hCursor)
		DllCall("DestroyIcon", "Ptr", hCursor)
		( hBMMask && DllCall("DeleteObject", "Ptr", hBMMask) )
		( hBMColor && DllCall("DeleteObject", "Ptr", hBMColor) )
	}
}

ScreenShotMenuHandling() {
	CurrentGui := App.Menu.CurrentPreviewGui
	pBitmap := App.Windows[CurrentGui].pBM
	Time := App.Windows[CurrentGui].Time

	if (A_ThisMenuItem = "Сохранить" || A_ThisMenuItem = "Сохранить в первоначальном размере")
		SaveScreenshot(pBitmap, Time)
	else if (A_ThisMenuItem = "Сохранить в текущем размере")
		SavePreviewCurrentSize(CurrentGui, pBitmap, Time)
	Gui, %CurrentGui%:Cancel
}

PreviewSaveToMenuHandling() {
	CurrentGui := App.Menu.CurrentPreviewGui
	pBitmap := App.Windows[CurrentGui].pBM
	Time := App.Windows[CurrentGui].Time
	Output := PreviewSaveToOutput(A_ThisMenuItem)

	if (Output != "")
		SaveScreenshot(pBitmap, Time, Output)
	Gui, %CurrentGui%:Cancel
}

PreviewSaveCurrentToMenuHandling() {
	CurrentGui := App.Menu.CurrentPreviewGui
	pBitmap := App.Windows[CurrentGui].pBM
	Time := App.Windows[CurrentGui].Time
	Output := PreviewSaveToOutput(A_ThisMenuItem)

	if (Output != "")
		SavePreviewCurrentSize(CurrentGui, pBitmap, Time, Output)
	Gui, %CurrentGui%:Cancel
}

SavePreviewCurrentSize(CurrentGui, pBitmap, Time, OutputOverride := "") {
	WinGetPos,,, W, H, % "ahk_id " App.Windows[CurrentGui].Hwnd
	DllCall("gdiplus\GdipCreateBitmapFromScan0", "Int", W, "Int", H, "Int", 0, "Int", 0x26200A, "Ptr", 0, "Ptr*", pBM)
	DllCall("gdiplus\GdipGetImageGraphicsContext", "Ptr", pBM, "Ptr*", G)
	DllCall("gdiplus\GdipSetInterpolationMode", "Ptr", G, "Int", App.Config.InterpolationMode-1)

	GetImageDimensions(pBitmap, WidthBM, HeightBM)
	DrawImage(G, pBitmap, -Round(W/400), -Round(H/400)
		, Ceil(W*1.005), Ceil(H*1.005), 0, 0, WidthBM, HeightBM)

	DllCall("gdiplus\GdipDeleteGraphics", "Ptr", G)
	SaveScreenshot(pBM, Time, OutputOverride)
}

PreviewSaveToOutput(MenuItem) {
	if (MenuItem = "файл")
		return "File"
	if (MenuItem = "буфер обмена")
		return "Clip"
	if (MenuItem = "imgbb.com")
		return "Imgbb"
	return ""
}

SaveBitmap(pBitmap, ByRef info, Quality := 75, tobuff := "") {
	if tobuff
		Extension := info
	else
		SplitPath, info,,, Extension
   if Extension not in BMP,DIB,RLE,JPG,JPEG,JPE,JFIF,GIF,TIF,TIFF,PNG
      return -1

   DllCall("gdiplus\GdipGetImageEncodersSize", "UInt*", nCount, "UInt*", nSize)
   VarSetCapacity(ci, nSize)
   DllCall("gdiplus\GdipGetImageEncoders", "UInt", nCount, "UInt", nSize, "Ptr", &ci)
   if !(nCount && nSize)
      return -2
   
	Loop, % nCount {
		sString := StrGet(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
	}
   
   if !pCodec
      return -3
	
	if RegExMatch(Extension, "i)^J(PG|PEG|PE|FIF)$") && Quality != 75 {
		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_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 !tobuff {
		if A_IsUnicode
			pOutput := &info
		else {
			VarSetCapacity(wOutput, StrPut(info, "UTF-16")*2, 0)
			StrPut(info, &wOutput, "UTF-16")
			pOutput := &wOutput
		}
		E := DllCall("gdiplus\GdipSaveImageToFile", "Ptr", pBitmap, "Ptr", pOutput, "Ptr", pCodec, "UInt", p ? p : 0)
	}
	else {
		DllCall( "ole32\CreateStreamOnHGlobal", "UInt", 0, "Int", 1, "Ptr*", pStream )
		if E := DllCall( "gdiplus\GdipSaveImageToStream", "Ptr", pBitmap, "Ptr", pStream, "Ptr", pCodec, "UInt", p ? p : 0 )
			DllCall( NumGet( NumGet( 1*pStream ) + A_PtrSize*2 ), "Ptr", pStream )
		else {
			DllCall( "ole32\GetHGlobalFromStream", "Ptr", pStream, "Ptr*", hData )
			pData := DllCall( "GlobalLock", "Ptr", hData )
			nSize := DllCall( "GlobalSize", "Ptr", hData )
			VarSetCapacity( info, 0), VarSetCapacity( info, nSize, 0 )
			DllCall( "RtlMoveMemory", "Ptr", &info, "Ptr", pData, "UInt", nSize )
			DllCall( "GlobalUnlock", "Ptr", hData )
			DllCall( NumGet( NumGet( 1*pStream ) + A_PtrSize*2 ), "Ptr", pStream )
			DllCall( "GlobalFree", "Ptr", hData )
		}
	}
   return E ? -4 : tobuff ? nSize : 0
}

SetBitmapToClipboard(pBitmap) {
	off1 := A_PtrSize = 8 ? 52 : 44, off2 := A_PtrSize = 8 ? 32 : 24
	DllCall("gdiplus\GdipCreateHBITMAPFromBitmap", "Ptr", pBitmap, "Ptr*", hBitmap, "Int", 0xFFFFFFFF)
	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, "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")
}

CreateDIBSection(w, h, hdc="", bpp=32, ByRef ppvBits=0) {
	hdc2 := hdc ? hdc : DllCall("GetDC", "Ptr", 0)
	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, "Ptr*", ppvBits, "Ptr", 0, "UInt", 0, "Ptr")

	( !hdc && DllCall("ReleaseDC", "Ptr", 0, "Ptr", hdc2) )
	return hbm
}

UpdateLayeredWindow(hwnd, hdc, x="", y="", w="", h="", Alpha=255) {
	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 )
}

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

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

SetStaticColor(hStatic, b_color, f_color := 0) {
	static arr := [], GWL_WNDPROC := -4
	b_color := DllCall("Ws2_32\ntohl", "UInt", b_color << 8, "UInt")
	f_color := DllCall("Ws2_32\ntohl", "UInt", f_color << 8, "UInt")
	hGui := DllCall("GetParent", "Ptr", hStatic, "Ptr")
	if !arr.HasKey(hGui) {
		arr[hGui] := {}, arr[hGui].Statics := []
		arr[hGui].ProcOld := DllCall("SetWindowLong" . (A_PtrSize = 8 ? "Ptr" : ""), "Ptr", hGui, "Int", GWL_WNDPROC
														, "Ptr", RegisterCallback("WindowProc", "", 4, Object(arr[hGui])), "Ptr")
	}
	else if arr[hGui].Statics.HasKey(hStatic)
		DllCall("DeleteObject", "Ptr", arr[hGui].Statics[hStatic].hBrush)
	arr[hGui].Statics[hStatic] := { b_color: b_color, f_color: f_color
								  , hBrush: DllCall("CreateSolidBrush", "UInt", b_color, "Ptr") }
	WinSet, Redraw,, ahk_id %hStatic%
}

WindowProc(hwnd, uMsg, wParam, lParam) {
	Critical
	static WM_CTLCOLORSTATIC := 0x138
	obj := Object(A_EventInfo)
	if (uMsg = WM_CTLCOLORSTATIC && k := obj.Statics[lParam]) {
		DllCall("SetBkColor", "Ptr", wParam, "UInt", k.b_color)
		DllCall("SetTextColor", "Ptr", wParam, "UInt", k.f_color)
		return k.hBrush
	}
	return DllCall("CallWindowProc", "Ptr", obj.ProcOld, "Ptr", hwnd, "UInt", uMsg, "Ptr", wParam, "Ptr", lParam)
}

CryptBinaryToStringBASE64(pData, Bytes, NOCRLF = "") {
    static CRYPT_STRING_BASE64 := 1, CRYPT_STRING_NOCRLF := 0x40000000
    CRYPT := CRYPT_STRING_BASE64 | (NOCRLF ? CRYPT_STRING_NOCRLF : 0)
    
    DllCall("Crypt32\CryptBinaryToString", "Ptr", pData, "UInt", Bytes, "UInt", CRYPT, "Ptr", 0, "UInt*", Chars)
    VarSetCapacity(OutData, Chars * (A_IsUnicode ? 2 : 1))
    DllCall("Crypt32\CryptBinaryToString", "Ptr", pData, "UInt", Bytes, "UInt", CRYPT, "Str", OutData, "UInt*", Chars)
    return OutData
}

CreateIconFromBase64(StringBASE64, Size) {
    DllCall("Crypt32.dll\CryptStringToBinary", "Ptr", &StringBase64
       , "UInt", StrLen(StringBase64), "UInt", CRYPT_STRING_BASE64 := 1, "UInt", 0, "UInt*", Bytes, "UInt*", 0, "UInt*", 0)
 
    VarSetCapacity(IconData, Bytes) 
    DllCall("Crypt32.dll\CryptStringToBinary", "Ptr", &StringBase64 
       , "UInt", StrLen(StringBase64), "UInt", CRYPT_STRING_BASE64, "Str", IconData, "UInt*", Bytes, "UInt*", 0, "UInt*", 0)
       
    return DllCall("CreateIconFromResourceEx", "Ptr", &IconData + 4
       , "UInt", NumGet(&IconData, "UInt"), "UInt", true, "UInt", 0x30000, "Int", Size, "Int", Size, "UInt", 0, "Ptr")
}

GetBase64String(Size) {
	Icon16 = 
	(RTrim Join
	aAQAACgAAAAQAAAAIAAAAAEAIAAAAAAAQAQAAAAAAAAAAAAAAAAAAAAAAAD///+3
	////////////////////////////////////////////////////////////////
	//////////////+3/////8H2/v865Pz/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/zLi/P+u9P7///////////8w4vz/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/H+D8////////////
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P///////////xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z///////////8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8////////////
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P///////////xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z///////////8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8////////////
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P///////////xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z///////////8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8////////////
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P///////////zDi/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8f4Pz////////////G9/7/Sub9/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P9A5Pz/tPT+//////////+3
	////////////////////////////////////////////////////////////////
	//////////////+3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
	AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==
	)
	
	Icon32 = 
	(RTrim Join
	qBAAACgAAAAgAAAAQAAAAAEAIAAAAAAAgBAAAAAAAAAAAAAAAAAAAAAAAAC9vr5avb6+5L2+vv+9vr7/vb6+/72+vv+9vr7/vb6+/72+vv+9vr7/vb6+/72+vv+9vr7/
	vb6+/72+vv+9vr7/vb6+/72+vv+9vr7/vb6+/72+vv+9vr7/vb6+/72+vv+9vr7/vb6+/72+vv+9vr7/vb6+/72+vv+9vr7kvb6+Wr2+vvO9vr7/vb6+/72+vv+9vr7/
	vb6+/72+vv+9vr7/vb6+/72+vv+9vr7/vb6+/72+vv+9vr7/vb6+/72+vv+9vr7/vb6+/72+vv+9vr7/vb6+/72+vv+9vr7/vb6+/72+vv+9vr7/vb6+/72+vv+9vr7/
	vb6+/72+vv+9vr7zvb6+/72+vv+LyNH/Ldv1/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/y3b9f+LyNH/vb6+/72+vv+9vr7/vb6+/ybd+P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/ybd+P+9vr7/vb6+/72+vv+zwML/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/7PAwv+9vr7/vb6+/7PAwv8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/s8DC/72+vv+9vr7/s8DC/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P+zwML/vb6+/72+vv+zwML/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/7PAwv+9vr7/vb6+/7PAwv8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/s8DC/72+vv+9vr7/s8DC/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P+zwML/vb6+/72+vv+zwML/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/7PAwv+9vr7/vb6+/7PAwv8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/s8DC/72+vv+9vr7/s8DC/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P+zwML/vb6+/72+vv+zwML/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/7PAwv+9vr7/vb6+/7PAwv8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/s8DC/72+vv+9vr7/s8DC/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P+zwML/vb6+/72+vv+zwML/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/7PAwv+9vr7/vb6+/7PAwv8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/s8DC/72+vv+9vr7/s8DC/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P+zwML/vb6+/72+vv+zwML/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/7PAwv+9vr7/vb6+/7PAwv8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/s8DC/72+vv+9vr7/s8DC/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P+zwML/vb6+/72+vv+zwML/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/7PAwv+9vr7/vb6+/7PAwv8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/s8DC/72+vv+9vr7/s8DC/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P+zwML/vb6+/72+vv+zwML/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/7PAwv+9vr7/vb6+/7PAwv8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/s8DC/72+vv+9vr7/s8DC/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P+zwML/vb6+/72+vv+9vr7/Jt34/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Jt34/72+vv+9vr7/vb6+/72+vv+NyND/O9jw/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/
	Gt/8/xrf/P8a3/z/Gt/8/xrf/P8a3/z/Gt/8/zvY8P+NyND/vb6+/72+vv+9vr72vb6+/72+vv+9vr7/vb6+/72+vv+9vr7/vb6+/72+vv+9vr7/vb6+/72+vv+9vr7/
	vb6+/72+vv+9vr7/vb6+/72+vv+9vr7/vb6+/72+vv+9vr7/vb6+/72+vv+9vr7/vb6+/72+vv+9vr7/vb6+/72+vv+9vr7/vb6+9r2+vmC9vr7wvb6+/72+vv+9vr7/
	vb6+/72+vv+9vr7/vb6+/72+vv+9vr7/vb6+/72+vv+9vr7/vb6+/72+vv+9vr7/vb6+/72+vv+9vr7/vb6+/72+vv+9vr7/vb6+/72+vv+9vr7/vb6+/72+vv+9vr7/
	vb6+/72+vvC9vr5gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
	AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=
	)
	return Icon%Size%
}

; Full-screen mouse selection overlay.
class OverlaySelection {
    static WM_MOUSEMOVE := 0x0200

    __New(thickness := 2, color := 0x00FF00, labelSpecs := "", armedStyle := "") {
        this.scale := A_ScreenDPI / 96
        this.overlay := new SelectionOverlayFrame(thickness, color, this.scale)
        this.state := "idle"
        this.busy := false
        this.startX := 0
        this.startY := 0
        this.curX := 0
        this.curY := 0
        this.callback := ""
        this.callbackTimer := ""
        this.disposed := false
        this.onMove := ObjBindMethod(this, "OnMouseMove")
        this.labels := []
        this.providers := []

        specs := IsObject(labelSpecs) ? labelSpecs : OverlaySelection.DefaultSpecs()
        for index, spec in specs {
            style := spec.HasKey("style") ? spec.style : {}
            this.labels.Push(new SelectionOverlayLabel(style, this.scale))
            this.providers.Push(spec.provider)
        }

        if !IsObject(armedStyle)
            armedStyle := {}
        this.armedLabel := new SelectionOverlayLabel(armedStyle, this.scale)
        this.armedOffsetX := armedStyle.HasKey("offsetX") ? armedStyle.offsetX : 12
        this.armedOffsetY := armedStyle.HasKey("offsetY") ? armedStyle.offsetY : 12
    }

    DefaultSpecs() {
        gap := 5
        return [ {style: {}, provider: Func("OverlayTopLabelProvider").Bind(gap)}
               , {style: {}, provider: Func("OverlayBottomLabelProvider").Bind(gap)} ]
    }

    Arm(callback, showArmedLabel := true) {
        if (this.state != "idle" || this.busy)
            return

        this.callback := callback
        this.overlay.ClearFrame()
        this.overlay.Show()
        this.state := "armed"
        OnMessage(this.WM_MOUSEMOVE, this.onMove)
        MouseGetPos, mx, my
        this.curX := mx
        this.curY := my
        if showArmedLabel
            this.UpdateArmed()
    }

    BeginDrag() {
        if (this.state != "armed")
            return

        MouseGetPos, mx, my
        this.startX := mx
        this.startY := my
        this.curX := mx
        this.curY := my
        this.overlay.ClearFrame()
        this.state := "dragging"
        this.Update()
    }

    Quick(callback) {
        if (this.state != "idle" || this.busy)
            return

        this.Arm(callback, false)
        this.BeginDrag()
        if !GetKeyState("LButton", "P")
            this.Finish()
    }

    Cancel() {
        if (this.state != "armed" && this.state != "dragging")
            return

        OnMessage(this.WM_MOUSEMOVE, this.onMove, 0)
        this.overlay.Hide()
        this.state := "idle"
    }

    OnMouseMove(wParam, lParam, msg, hwnd) {
        if (hwnd != this.overlay.hwnd)
            return

        pt := this.ClientPoint(lParam)
        this.curX := pt.x
        this.curY := pt.y
        if (this.state = "dragging")
            this.Update()
        else if (this.state = "armed")
            this.UpdateArmed()
    }

    ClientPoint(lParam) {
        x := lParam & 0xFFFF
        y := (lParam >> 16) & 0xFFFF
        if (x > 0x7FFF)
            x -= 0x10000
        if (y > 0x7FFF)
            y -= 0x10000

        VarSetCapacity(pt, 8, 0)
        NumPut(x, pt, 0, "Int")
        NumPut(y, pt, 4, "Int")
        DllCall("ClientToScreen", "Ptr", this.overlay.hwnd, "Ptr", &pt)
        return {x: NumGet(pt, 0, "Int"), y: NumGet(pt, 4, "Int")}
    }

    Rect() {
        x := Min(this.startX, this.curX)
        y := Min(this.startY, this.curY)
        w := Abs(this.curX - this.startX)
        h := Abs(this.curY - this.startY)
        return {x: x, y: y, w: w, h: h}
    }

    Update() {
        r := this.Rect()
        ctx := {r: r, t: this.overlay.PhysT(), scale: this.scale}
        for index, provider in this.providers {
            spec := provider.Call(ctx)
            this.labels[index].SetText(spec.text, spec.ax, spec.ay, spec.side)
        }
        this.overlay.Render(r, this.labels)
    }

    UpdateArmed() {
        x := this.curX
        y := this.curY
        anchorX := x - Round(this.armedOffsetX * this.scale)
        anchorY := y - Round(this.armedOffsetY * this.scale)
        this.armedLabel.SetText(x . ", " . y, anchorX, anchorY, "topLeft")
        this.overlay.RenderLabels([this.armedLabel])
    }

    Finish() {
        if (this.state != "dragging")
            return

        this.state := "idle"
        OnMessage(this.WM_MOUSEMOVE, this.onMove, 0)
        this.overlay.Hide()
        callback := this.callback
        if IsObject(callback) {
            this.busy := true
            r := this.Rect()
            this.callbackTimer := ObjBindMethod(this, "InvokeCallback", callback, r)
            timer := this.callbackTimer
            SetTimer, % timer, -1
        }
    }

    InvokeCallback(callback, r) {
        try callback.Call(r)
        finally {
            this.busy := false
            this.callbackTimer := ""
        }
    }

    Dispose() {
        if (this.disposed)
            return
        this.disposed := true

        if (this.state = "armed" || this.state = "dragging")
            OnMessage(this.WM_MOUSEMOVE, this.onMove, 0)
        if IsObject(this.callbackTimer) {
            timer := this.callbackTimer
            SetTimer, % timer, Delete
            this.callbackTimer := ""
        }
        for index, label in this.labels
            label.Dispose()
        if IsObject(this.armedLabel)
            this.armedLabel.Dispose()
        if IsObject(this.overlay)
            this.overlay.Dispose()
        this.state := "idle"
    }

    __Delete() {
        this.Dispose()
    }
}

class SelectionOverlayFrame {
    __New(thickness, color, scale := 1) {
        this.t := thickness
        this.scale := scale
        this.color := 0xFF000000 | color
        this.w := A_ScreenWidth
        this.h := A_ScreenHeight
        this.prev := ""
        this.disposed := false
		this.guiName := "SelectionOverlay"

		Gui, % this.guiName . ":New", +AlwaysOnTop -Caption +ToolWindow -DPIScale +E0x80000 +hwndOverlayHwnd
        this.hwnd := OverlayHwnd
		this.hArrow := DllCall("LoadCursor", "Ptr", 0, "Ptr", 32512, "Ptr")
        this.CreateBuffer()
    }

    CreateBuffer() {
        this.hdcMem := DllCall("CreateCompatibleDC", "Ptr", 0, "Ptr")

        VarSetCapacity(bi, 40, 0)
        NumPut(40, bi, 0, "UInt")
        NumPut(this.w, bi, 4, "Int")
        NumPut(-this.h, bi, 8, "Int")
        NumPut(1, bi, 12, "UShort")
        NumPut(32, bi, 14, "UShort")
        NumPut(0, bi, 16, "UInt")

        this.hbm := DllCall("CreateDIBSection", "Ptr", this.hdcMem, "Ptr", &bi
            , "UInt", 0, "Ptr*", pBits, "Ptr", 0, "UInt", 0, "Ptr")
        this.pBits := pBits
        this.oldBm := DllCall("SelectObject", "Ptr", this.hdcMem, "Ptr", this.hbm, "Ptr")

        DllCall("gdiplus\GdipCreateBitmapFromScan0", "Int", this.w, "Int", this.h
            , "Int", this.w * 4, "Int", 0xE200B, "Ptr", this.pBits, "Ptr*", pBitmap)
        this.pBitmap := pBitmap
        DllCall("gdiplus\GdipGetImageGraphicsContext", "Ptr", this.pBitmap, "Ptr*", pGraphics)
        this.pGraphics := pGraphics
        DllCall("gdiplus\GdipSetCompositingMode", "Ptr", this.pGraphics, "Int", 1)
        DllCall("gdiplus\GdipSetTextRenderingHint", "Ptr", this.pGraphics, "Int", 4)
        DllCall("gdiplus\GdipSetSmoothingMode", "Ptr", this.pGraphics, "Int", 3)

        DllCall("gdiplus\GdipCreateSolidFill", "UInt", this.color, "Ptr*", pBrush)
        this.pBrush := pBrush
        DllCall("gdiplus\GdipCreateSolidFill", "UInt", 0x01000000, "Ptr*", pErase)
        this.pErase := pErase
        DllCall("gdiplus\GdipGraphicsClear", "Ptr", this.pGraphics, "UInt", 0x01000000)
    }

    Show() {
        options := "NA x0 y0 w" . this.w . " h" . this.h
		Gui, % this.guiName . ":Show", % options
    }

    Hide() {
        if (this.disposed)
            return
        DllCall("gdiplus\GdipGraphicsClear", "Ptr", this.pGraphics, "UInt", 0x01000000)
        this.prev := ""
        this.Flush()
		Gui, % this.guiName . ":Hide"
		DllCall("SetCursor", "Ptr", this.hArrow)
    }

    ClearFrame() {
        DllCall("gdiplus\GdipGraphicsClear", "Ptr", this.pGraphics, "UInt", 0x01000000)
        this.prev := ""
        this.Flush()
    }

    SetRect(x, y, w, h) {
        cur := {x: x, y: y, w: w, h: h}
        if IsObject(this.prev)
            this.Strips(this.prev, this.pErase)
        this.Strips(cur, this.pBrush)
        this.prev := cur
        this.Flush()
    }

    Render(rect, labels) {
        for index, label in labels
            label.Erase(this.pGraphics, this.pErase)
        if IsObject(this.prev)
            this.Strips(this.prev, this.pErase)

        cur := {x: rect.x, y: rect.y, w: rect.w, h: rect.h}
        this.Strips(cur, this.pBrush)
        this.prev := cur
        for index, label in labels
            label.Draw(this.pGraphics, this.w, this.h)

        this.Flush()
        for index, label in labels
            label.Commit()
    }

    RenderLabels(labels) {
        for index, label in labels
            label.Erase(this.pGraphics, this.pErase)
        for index, label in labels
            label.Draw(this.pGraphics, this.w, this.h)

        this.Flush()
        for index, label in labels
            label.Commit()
    }

    PhysT() {
        return Max(1, Round(this.t * this.scale))
    }

    Strips(r, brush) {
        t := this.PhysT()
        this.Fill(brush, r.x - t, r.y - t, r.w + 2 * t, t)
        this.Fill(brush, r.x - t, r.y + r.h, r.w + 2 * t, t)
        this.Fill(brush, r.x - t, r.y, t, r.h)
        this.Fill(brush, r.x + r.w, r.y, t, r.h)
    }

    Fill(brush, x, y, w, h) {
        if (w < 1 || h < 1)
            return
        DllCall("gdiplus\GdipFillRectangle", "Ptr", this.pGraphics
            , "Ptr", brush, "Float", x, "Float", y, "Float", w, "Float", h)
    }

    Flush() {
        VarSetCapacity(pt, 8, 0)
        VarSetCapacity(sz, 8, 0)
        NumPut(this.w, sz, 0, "Int")
        NumPut(this.h, sz, 4, "Int")
        VarSetCapacity(src, 8, 0)
        VarSetCapacity(blend, 4, 0)
        NumPut(255, blend, 2, "UChar")
        NumPut(1, blend, 3, "UChar")

        DllCall("UpdateLayeredWindow", "Ptr", this.hwnd, "Ptr", 0
            , "Ptr", &pt, "Ptr", &sz, "Ptr", this.hdcMem, "Ptr", &src
            , "UInt", 0, "Ptr", &blend, "UInt", 2)
    }

    Dispose() {
        if (this.disposed)
            return
        this.disposed := true

        if (this.pBrush)
            DllCall("gdiplus\GdipDeleteBrush", "Ptr", this.pBrush)
        if (this.pErase)
            DllCall("gdiplus\GdipDeleteBrush", "Ptr", this.pErase)
        if (this.pGraphics)
            DllCall("gdiplus\GdipDeleteGraphics", "Ptr", this.pGraphics)
        if (this.pBitmap)
            DllCall("gdiplus\GdipDisposeImage", "Ptr", this.pBitmap)
        if (this.hbm) {
            DllCall("SelectObject", "Ptr", this.hdcMem, "Ptr", this.oldBm)
            DllCall("DeleteObject", "Ptr", this.hbm)
        }
        if (this.hdcMem)
            DllCall("DeleteDC", "Ptr", this.hdcMem)
		if (this.hwnd && DllCall("IsWindow", "Ptr", this.hwnd))
			Gui, % this.guiName . ":Destroy"

        this.pBrush := 0
        this.pErase := 0
        this.pGraphics := 0
        this.pBitmap := 0
        this.hbm := 0
        this.hdcMem := 0
		this.hArrow := 0
        this.hwnd := 0
    }

    __Delete() {
        this.Dispose()
    }
}

class SelectionOverlayLabel {
    __New(style := "", scale := 1) {
        if !IsObject(style)
            style := {}

        fontName := this.StyleValue(style, "fontName", "Segoe UI")
        fontSize := this.StyleValue(style, "fontSize", 14) * scale
        fontStyle := this.StyleValue(style, "fontStyle", 0)
        textColor := this.StyleValue(style, "textColor", 0xFFFFFF)
        backColor := this.StyleValue(style, "backColor", 0x202020)
        this.padX := Round(this.StyleValue(style, "padX", 6) * scale)
        this.padY := Round(this.StyleValue(style, "padY", 3) * scale)
        this.radius := Round(this.StyleValue(style, "radius", 6) * scale)
        this.text := ""
        this.box := ""
        this.eraseBox := ""
        this.prevErase := ""
        this.disposed := false

        DllCall("gdiplus\GdipCreateFontFamilyFromName", "WStr", fontName
            , "Ptr", 0, "Ptr*", family)
        this.family := family
        DllCall("gdiplus\GdipCreateFont", "Ptr", this.family, "Float", fontSize
            , "Int", fontStyle, "Int", 2, "Ptr*", font)
        this.font := font

        DllCall("gdiplus\GdipCreateStringFormat", "Int", 0, "Int", 0, "Ptr*", fmt)
        this.fmt := fmt
        DllCall("gdiplus\GdipSetStringFormatAlign", "Ptr", this.fmt, "Int", 0)
        DllCall("gdiplus\GdipSetStringFormatLineAlign", "Ptr", this.fmt, "Int", 1)

        DllCall("gdiplus\GdipCreateSolidFill", "UInt", 0xFF000000 | textColor, "Ptr*", textBrush)
        this.textBrush := textBrush
        DllCall("gdiplus\GdipCreateSolidFill", "UInt", 0xFF000000 | backColor, "Ptr*", backBrush)
        this.backBrush := backBrush
    }

    StyleValue(style, key, defaultValue) {
        return style.HasKey(key) ? style[key] : defaultValue
    }

    SetText(text, anchorX, anchorY, side := "top") {
        this.text := text
        this.ax := anchorX
        this.ay := anchorY
        this.side := side
    }

    Measure(pGraphics) {
        VarSetCapacity(layout, 16, 0)
        NumPut(0, layout, 0, "Float")
        NumPut(0, layout, 4, "Float")
        NumPut(9999, layout, 8, "Float")
        NumPut(9999, layout, 12, "Float")
        VarSetCapacity(bounds, 16, 0)
        DllCall("gdiplus\GdipMeasureString", "Ptr", pGraphics, "WStr", this.text
            , "Int", -1, "Ptr", this.font, "Ptr", &layout, "Ptr", this.fmt
            , "Ptr", &bounds, "Int*", chars, "Int*", lines)
        return {w: NumGet(bounds, 8, "Float"), h: NumGet(bounds, 12, "Float")}
    }

    ComputeBox(pGraphics, screenW, screenH) {
        metrics := this.Measure(pGraphics)
        bw := Ceil(metrics.w) + this.padX * 2
        bh := Ceil(metrics.h) + this.padY * 2

        if (this.side = "top") {
            bx := this.ax
            by := this.ay - bh - 1
        } else if (this.side = "bottom") {
            bx := this.ax - bw
            by := this.ay
        } else if (this.side = "left") {
            bx := this.ax - bw
            by := this.ay - bh // 2
        } else if (this.side = "right") {
            bx := this.ax
            by := this.ay - bh // 2
        } else if (this.side = "topLeft") {
            bx := this.ax - bw
            by := this.ay - bh - 1
        } else {
            bx := this.ax - bw // 2
            by := this.ay - bh // 2
        }

        bx := Max(0, Min(bx, screenW - bw))
        by := Max(0, Min(by, screenH - bh))
        return {x: bx, y: by, w: bw, h: bh}
    }

    Draw(pGraphics, screenW, screenH) {
        if (this.text = "") {
            this.box := ""
            this.eraseBox := ""
            return
        }

        box := this.ComputeBox(pGraphics, screenW, screenH)
        this.box := box
        ex := Max(0, box.x - 1)
        ey := Max(0, box.y - 1)
        er := Min(screenW, box.x + box.w + 1)
        eb := Min(screenH, box.y + box.h + 1)
        this.eraseBox := {x: ex, y: ey, w: er - ex, h: eb - ey}

        DllCall("gdiplus\GdipSetCompositingMode", "Ptr", pGraphics, "Int", 0)
        this.FillRoundRect(pGraphics, box.x, box.y, box.w, box.h, this.radius, this.backBrush)

        VarSetCapacity(rect, 16, 0)
        NumPut(box.x + this.padX, rect, 0, "Float")
        NumPut(box.y, rect, 4, "Float")
        NumPut(box.w, rect, 8, "Float")
        NumPut(box.h, rect, 12, "Float")
        DllCall("gdiplus\GdipDrawString", "Ptr", pGraphics, "WStr", this.text
            , "Int", -1, "Ptr", this.font, "Ptr", &rect, "Ptr", this.fmt
            , "Ptr", this.textBrush)
        DllCall("gdiplus\GdipSetCompositingMode", "Ptr", pGraphics, "Int", 1)
    }

    FillRoundRect(pGraphics, x, y, w, h, radius, brush) {
        radius := Min(radius, Min(w // 2, h // 2))
        diameter := radius * 2
        DllCall("gdiplus\GdipCreatePath", "Int", 0, "Ptr*", path)
        if (radius > 0) {
            DllCall("gdiplus\GdipAddPathArc", "Ptr", path, "Float", x
                , "Float", y, "Float", diameter, "Float", diameter, "Float", 180, "Float", 90)
            DllCall("gdiplus\GdipAddPathArc", "Ptr", path, "Float", x + w - diameter
                , "Float", y, "Float", diameter, "Float", diameter, "Float", 270, "Float", 90)
            DllCall("gdiplus\GdipAddPathArc", "Ptr", path, "Float", x + w - diameter
                , "Float", y + h - diameter, "Float", diameter, "Float", diameter, "Float", 0, "Float", 90)
            DllCall("gdiplus\GdipAddPathArc", "Ptr", path, "Float", x
                , "Float", y + h - diameter, "Float", diameter, "Float", diameter, "Float", 90, "Float", 90)
            DllCall("gdiplus\GdipClosePathFigure", "Ptr", path)
        } else {
            DllCall("gdiplus\GdipAddPathRectangle", "Ptr", path
                , "Float", x, "Float", y, "Float", w, "Float", h)
        }

        DllCall("gdiplus\GdipSetSmoothingMode", "Ptr", pGraphics, "Int", 4)
        DllCall("gdiplus\GdipFillPath", "Ptr", pGraphics, "Ptr", brush, "Ptr", path)
        DllCall("gdiplus\GdipSetSmoothingMode", "Ptr", pGraphics, "Int", 3)
        DllCall("gdiplus\GdipDeletePath", "Ptr", path)
    }

    Erase(pGraphics, eraseBrush) {
        if !IsObject(this.prevErase)
            return
        box := this.prevErase
        DllCall("gdiplus\GdipFillRectangle", "Ptr", pGraphics, "Ptr", eraseBrush
            , "Float", box.x, "Float", box.y, "Float", box.w, "Float", box.h)
    }

    Commit() {
        this.prevErase := this.eraseBox
    }

    Dispose() {
        if (this.disposed)
            return
        this.disposed := true

        if (this.textBrush)
            DllCall("gdiplus\GdipDeleteBrush", "Ptr", this.textBrush)
        if (this.backBrush)
            DllCall("gdiplus\GdipDeleteBrush", "Ptr", this.backBrush)
        if (this.fmt)
            DllCall("gdiplus\GdipDeleteStringFormat", "Ptr", this.fmt)
        if (this.font)
            DllCall("gdiplus\GdipDeleteFont", "Ptr", this.font)
        if (this.family)
            DllCall("gdiplus\GdipDeleteFontFamily", "Ptr", this.family)

        this.textBrush := 0
        this.backBrush := 0
        this.fmt := 0
        this.font := 0
        this.family := 0
    }

    __Delete() {
        this.Dispose()
    }
}

class ToolTip {
    ; Default options. Any option omitted by the caller falls back to the value here.
    ; Color options use "" to mean "leave the system default" (0 is a valid black).
    DefaultOptions() {
        return { text: "", title: "", icon: 0
               , x: "", y: "", TimeOut: "", ShowNow: true
               , FontName: "", FontSize: 0, FontStyle: ""
               , BackColor: "", TextColor: "", Margin: ""
               , BalloonTip: false, CloseButton: false
			   , transparent: true, RightBottom: false, TrayTip: false }
    }

    __New( options ) {
        defaults := this.DefaultOptions()
        for k, v in defaults
            this[k] := options.HasKey(k) ? options[k] : v
        this._CreateToolTip()
        ( this.ShowNow && this.Show(this.x, this.y, this.TimeOut) )
    }
    
    _CreateToolTip() {
        static WS_POPUP := 0x80000000, WS_EX_TOPMOST := 8, WS_EX_TRANSPARENT := 0x20
              , TTS_NOPREFIX := 2, TTS_ALWAYSTIP := 1, TTS_BALLOON := 0x40, TTS_CLOSE := 0x80
              , TTF_TRACK := 0x20, TTF_ABSOLUTE := 0x80, szTI := A_PtrSize = 4 ? 48 : 72
      
        VarSetCapacity(TOOLINFO, szTI, 0)
        this.pTI := &TOOLINFO
        NumPut(szTI, TOOLINFO)
        (this.TrayTip && this.BalloonTip := true)
        (this.CloseButton && this.transparent := false)
        NumPut(TTF_TRACK|(this.BalloonTip ? 0 : TTF_ABSOLUTE), &TOOLINFO + 4)
        
        this.hwnd := DllCall("CreateWindowEx", "UInt", WS_EX_TOPMOST|(this.transparent ? WS_EX_TRANSPARENT : 0)
          , "Str", "tooltips_class32", "Str", ""
          , "UInt", WS_POPUP | TTS_NOPREFIX | TTS_ALWAYSTIP | (this.CloseButton ? TTS_CLOSE : 0) | (this.BalloonTip ? TTS_BALLOON : 0)
          , "Int", 0, "Int", 0, "Int", 0, "Int", 0, "Ptr", 0, "Ptr", 0, "Ptr", 0, "Ptr", 0)
          
        if (this.FontName || this.FontSize || this.FontStyle)
            this._SetFont()
        
        if (this.TextColor != "" || this.BackColor != "")
            this._SetColor()
        
        this._SetInfo()
    }
    
    _SetFont() {
        static WM_GETFONT := 0x31, mult := A_IsUnicode ? 2 : 1, szLF := 28 + 32 * mult
             , LOGPIXELSY := 90, ANTIALIASED_QUALITY := 4
             , styles := { bold: {value: 700, offset: 16, size: "Int"}
                         , italic: {value: 1, offset: 20, size: "Char"}
                         , underline: {value: 1, offset: 21, size: "Char"}
                         , strikeout: {value: 1, offset: 22, size: "Char"} }
                              
        hPrevFont := this._SendMessage(WM_GETFONT)
        VarSetCapacity(LOGFONT, szLF, 0)
        DllCall("GetObject", "Ptr", hPrevFont, "Int", szLF, "Ptr", &LOGFONT)
        DllCall("DeleteObject", "Ptr", hPrevFont)
        
        if this.FontSize {
            hDC := DllCall("GetDC", "Ptr", this.hwnd, "Ptr")
			picH := DllCall("GetDeviceCaps", "Ptr", hDC, "Int", LOGPIXELSY)
            height := -DllCall("MulDiv", "Int", this.FontSize, "Int", picH, "Int", 72)
            DllCall("ReleaseDC", "Ptr", this.hwnd, "Ptr", hDC)
            NumPut(height, LOGFONT, "Int")
        }
        FontStyle := this.FontStyle
        Loop, parse, FontStyle, %A_Space%
		{
            if obj := styles[A_LoopField]
                NumPut(obj.value, &LOGFONT + obj.offset, obj.size)
		}
        (this.FontSize > 24 && NumPut(ANTIALIASED_QUALITY, &LOGFONT + 26, "Char"))
        this.FontName && StrPut(this.FontName, &LOGFONT + 28, StrLen(this.FontName) * mult, A_IsUnicode ? "UTF-16" : "CP0")
        this.hFont := DllCall("CreateFontIndirect", "Ptr", &LOGFONT, "Ptr")
    }
    
    _SetColor() {
        static WM_USER := 0x400, TTM_SETTIPBKCOLOR := WM_USER + 19, TTM_SETTIPTEXTCOLOR := WM_USER + 20
        
        VarSetCapacity(empty, 2, 0)
        DllCall("UxTheme\SetWindowTheme", "Ptr", this.hwnd, "Ptr", 0, "Ptr", &empty)   
        ( this.TextColor != "" && this._SendMessage(TTM_SETTIPTEXTCOLOR, this._GetColor(this.TextColor)) )
        ( this.BackColor != "" && this._SendMessage(TTM_SETTIPBKCOLOR, this._GetColor(this.BackColor)) )
    }
    
    _GetColor(color) {
        static WS_CHILD := 0x40000000, WM_CTLCOLORSTATIC := 0x138
        
        Gui, New, +hwndhGui +%WS_CHILD%
        Gui, Color, % color + 0 = "" ? color : Format("{:x}", color)
        Gui, Add, Text, hwndhText
        hdc := DllCall("GetDC", "Ptr", hText, "Ptr")
        SendMessage, WM_CTLCOLORSTATIC, hdc, hText,, ahk_id %hGui%
        clr := DllCall("GetBkColor", "Ptr", hdc)
        DllCall("ReleaseDC", "Ptr", hText, "Ptr", hdc)
        Gui, Destroy
        return clr
    }
    
    _SetInfo() {
        static WM_USER := 0x400, TTM_SETMAXTIPWIDTH := WM_USER + 24
              , TTM_ADDTOOL := WM_USER + (A_IsUnicode ? 50 : 4), WM_SETFONT := 0x30
        
        this._SendMessage(WM_SETFONT, this.hFont, 1)
        this._SendMessage(TTM_ADDTOOL, 0, this.pTI)
        this.SetTitle(this.icon, this.title)
        this._SendMessage(TTM_SETMAXTIPWIDTH, 0, A_ScreenWidth)
        this._SetMargin()
        this.SetText(this.text)
    }
    
    _SetMargin() {
        static WM_USER := 0x400, TTM_SETMARGIN := WM_USER + 26
        
        margin := this.Margin
        if !(IsObject(margin) && margin.MaxIndex() = 4)
            return
        VarSetCapacity(RECT, 16, 0)
        for i, offset in margin
            NumPut(offset, &RECT + (i - 1) * 4, "Int")
        this._SendMessage(TTM_SETMARGIN, 0, &RECT)
    }
    
    SetText(text) {
        static WM_USER := 0x400, TTM_UPDATETIPTEXT := WM_USER + (A_IsUnicode ? 57 : 12)
        NumPut(&text, this.pTI + (A_PtrSize = 4 ? 36 : 48))
        this._SendMessage(TTM_UPDATETIPTEXT, 0, this.pTI)
    }
    
    SetTitle(icon := "", title := "") {
        static WM_USER := 0x400, TTM_SETTITLE := WM_USER + (A_IsUnicode ? 33 : 32), TTM_UPDATE := WM_USER + 29
        
        ((icon || this.CloseButton) && title = "") && title := " "
        this._SendMessage(TTM_SETTITLE, icon, &title)
        (icon > 3 && DllCall("DestroyIcon", "Ptr", icon))
        this._SendMessage(TTM_UPDATE)
    }
    
    Show(x := "", y := "", timeout := "") {
        static WM_USER := 0x400, TTM_TRACKACTIVATE := WM_USER + 17, TTM_TRACKPOSITION := WM_USER + 18
        
        SysGet, MonPrimary, MonitorPrimary
        SysGet, Mon, MonitorWorkArea, %MonPrimary%
        xTT := x, yTT := y
        
        ; TrayTip mode: anchor the balloon to the script's tray icon (one-shot)
        if this.TrayTip {
            this._GetTrayIconCoords(xTT, yTT)
        ; RightBottom mode: push beyond the work area so the post-activation
        ; clamp below pins the tip to the bottom-right corner, above the taskbar
        } else if this.RightBottom {
            xTT := MonRight, yTT := MonBottom
        } else if (xTT = "" || yTT = "") {
            CoordMode, Mouse
            MouseGetPos, xm, ym
            (xTT = "" && xTT := xm + 10)
            (yTT = "" && yTT := ym + 10)
        }
        
        this._SendMessage(TTM_TRACKPOSITION, 0, xTT|(yTT<<16))
        this._SendMessage(TTM_TRACKACTIVATE, 1, this.pTI)
        
        if this.BalloonTip
            xMax := MonRight, yMax := MonBottom
        else {
            WinGetPos,,, W, H, % "ahk_id" this.hwnd
            xMax := MonRight - W - 10
            yMax := MonBottom - H - 10
        }
        
        if (xTT > xMax || yTT > yMax) {
            (xTT > xMax && xTT := xMax)
            (yTT > yMax && yTT := yMax)
            this._SendMessage(TTM_TRACKPOSITION, 0, xTT|(yTT<<16))
        }

        if timeout {
            timer := this.timer
            try SetTimer, % timer, Delete
            this.timer := timer := ObjBindMethod(this, timeout > 0 ? "Hide" : "Destroy")
            SetTimer % timer, % "-" . Abs(timeout)
        }
    }
    
    Hide() {
        static WM_USER := 0x400, TTM_TRACKACTIVATE := WM_USER + 17
        this._SendMessage(TTM_TRACKACTIVATE, 0, this.pTI)
    }
    
    Destroy() {
        this.__Delete()
        this.SetCapacity(0)
        this.base := ""
    }
    
    _SendMessage(msg, wp := 0, lp := 0) {
        return DllCall("SendMessage", "Ptr", this.hwnd, "UInt", msg, "Ptr", wp, "Ptr", lp, "Ptr")
    }
    
    _GetTrayIconCoords(ByRef x, ByRef y) {
        static AHK_NOTIFYICON := 0x404, szNII := 16 + 3 * A_PtrSize
        
        ; Modern, Win11-safe way: ask the shell for the icon's screen rect directly.
        VarSetCapacity(NII, szNII, 0)
        NumPut(szNII, NII, 0, "UInt")
        NumPut(A_ScriptHwnd, NII, A_PtrSize, "Ptr")
        NumPut(AHK_NOTIFYICON, NII, A_PtrSize * 2, "UInt")
        VarSetCapacity(RECT, 16, 0)
        
        if (DllCall("Shell32\Shell_NotifyIconGetRect", "Ptr", &NII, "Ptr", &RECT, "UInt") = 0) {
            xL := NumGet(RECT, 0, "Int"), yT := NumGet(RECT, 4, "Int")
            xR := NumGet(RECT, 8, "Int")
            x := (xL + xR) // 2   ; balloon anchors its tail at this point
            y := yT
        } else {
            ; Fallback: aim at the tray notification area as a whole.
            for k, v in ["TrayNotifyWnd", "SysPager", "ToolbarWindow32"]
                hTray := DllCall("FindWindowEx", "Ptr", k = 1 ? WinExist("ahk_class Shell_TrayWnd") : hTray, "Ptr", 0, "Str", v, "UInt", 0, "Ptr")
            WinGetPos, xTray, yTray, wTray,, % "ahk_id" hTray
            x := xTray + wTray // 2, y := yTray
        }
    }
    
    __Delete() {
        (this.hFont && DllCall("DeleteObject", "Ptr", this.hFont))
        (this.Icon > 3 && DllCall("DestroyIcon", "Ptr", this.Icon))
        DllCall("DestroyWindow", "Ptr", this.hwnd)
    }
}

;*************************************************************** HotKeys ***************************************************************

;  Автор - serzh82saratov
;  E-Mail: serzh82saratov@mail.ru
;  Описание - http://forum.script-coding.com/viewtopic.php?id=8343

Hotkey_Register(Controls*) {
    static IsStart
    for k, v in Controls
    {
        Hotkey_ID(v[2], v[1]), Hotkey_ID(v[1], v[2])
        Hotkey_Options(v[2], v[3] = "" ? "K" : v[3])
        Hotkey_Value(v[2], Hotkey_Value(v[1]))
        PostMessage, 0x00CF, 1, , , % "ahk_id" v[2]   ;  EM_SETREADONLY
        if RegExMatch(v[3], "i)G(\d+)", g)
            Hotkey_Group("Set", v[1], g1)
    }
    if IsStart
        return Hotkey_IsRegFocus()
    #HotkeyInterval 0
    Hotkey_SetWinEventHook(0x8005, 0x8005, 0, RegisterCallback("Hotkey_EventFocus", "F"), 0, 0, 0)   ;  EVENT_OBJECT_FOCUS := 0x8005
    Hotkey_InitHotkeys(), Hotkey_IsRegFocus(), IsStart := 1
}

Hotkey_Main(Param1, Param2 = "") {
    static OnlyMods, ControlHandle, Hotkey, KeyName, K := {}
    , Prefix := {"LAlt":"<!","LCtrl":"<^","LShift":"<+","LWin":"<#"
                ,"RAlt":">!","RCtrl":">^","RShift":">+","RWin":">#"
                ,"Alt":"!","Ctrl":"^","Shift":"+","Win":"#"}
    , EngSym := {"sc2":"1","sc3":"2","sc4":"3","sc5":"4","sc6":"5","sc7":"6"
                ,"sc8":"7","sc9":"8","scA":"9","scB":"0","scC":"-","scD":"="
                ,"sc10":"Q","sc11":"W","sc12":"E","sc13":"R","sc14":"T","sc15":"Y"
                ,"sc16":"U","sc17":"I","sc18":"O","sc19":"P","sc1A":"[","sc1B":"]"
                ,"sc1E":"A","sc1F":"S","sc20":"D","sc21":"F","sc22":"G","sc23":"H"
                ,"sc24":"J","sc25":"K","sc26":"L","sc27":"`;","sc28":"'","sc29":"``"
                ,"sc2B":"\","sc2C":"Z","sc2D":"X","sc2E":"C","sc2F":"V","sc30":"B"
                ,"sc31":"N","sc32":"M","sc33":",","sc34":".","sc35":"/"}

    if Param1 = GetMod
        return K.MLCtrl K.MRCtrl K.MLAlt K.MRAlt K.MLShift K.MRShift K.MLWin K.MRWin K.MCtrl K.MAlt K.MShift K.MWin
    if Param2
    {
        if OnlyMods
        {
            SendMessage, 0xC, 0, "" Hotkey_Arr("Empty"), , ahk_id %ControlHandle%
            OnlyMods := 0, K := {}
        }
        ControlHandle := Param2
        Hotkey_Arr("Hook", Hotkey_Options(ControlHandle))
        PostMessage, 0x00B1, -1, -1, , ahk_id %ControlHandle%   ;  EM_SETSEL
    }
    else if Hotkey_Arr("Hook")
    {
        Hotkey_Arr("Hook", 0), K := {}
        if OnlyMods
            SendMessage, 0xC, 0, "" Hotkey_Arr("Empty"), , ahk_id %ControlHandle%
        SetTimer, Hotkey_IsRegFocus, -200
    }
    return

Hotkey_Mods:
    if InStr(Hotkey_Arr("Hook"), "S")
        GoTo Hotkey_View
    IsMod := InStr(Hotkey_Arr("Hook"), "D") ? A_ThisHotkey : SubStr(A_ThisHotkey, 2)
    if (K["M" IsMod] != "")
        return
    K["M" IsMod] := IsMod "+", K["P" IsMod] := Prefix[IsMod]
    GoTo Hotkey_ViewMod

Hotkey_ModsUp:
    if InStr(Hotkey_Arr("Hook"), "S")
        return
    IsMod := InStr(Hotkey_Arr("Hook"), "D") ? SubStr(A_ThisHotkey, 1, -3) : SubStr(A_ThisHotkey, 2, -3)
    K["M" IsMod] := "", K["P" IsMod] := ""
    if (Hotkey != "")
        return

Hotkey_ViewMod:
    Hotkey := "", OnlyMods := 1, Hotkey_Value(Hotkey_ID(ControlHandle), K.Prefix Hotkey), Hotkey_Value(ControlHandle, K.Prefix Hotkey)
    K.Mods := K.MLCtrl K.MRCtrl K.MLAlt K.MRAlt K.MLShift K.MRShift K.MLWin K.MRWin K.MCtrl K.MAlt K.MShift K.MWin
    Text := K.Mods = "" ? Hotkey_Arr("Empty") : K.Mods
    SendMessage, 0xC, 0, &Text, , ahk_id %ControlHandle%
    return

Hotkey_ViewNum:
    if InStr(Hotkey_Arr("Hook"), "N")
        KeyName := Hotkey := GetKeyName(A_ThisHotkey)
    else
        KeyName := GetKeyName(A_ThisHotkey), Hotkey := Format("sc{:x}", GetKeySC(A_ThisHotkey))
    GoTo, Hotkey_Put

Hotkey_ViewSC:
    KeyName := Hotkey_Arr("OnlyEngSym") ? EngSym[A_ThisHotkey] : Format("{:U}", GetKeyName(A_ThisHotkey))
    Hotkey := A_ThisHotkey
    GoTo, Hotkey_Put

Hotkey_View:
    if (A_ThisHotkey = "Backspace")
        GoTo, Hotkey_Clear
    if Hotkey_IsMouseInput(A_ThisHotkey)
        Hotkey_SyncPhysicalModifiers(K)
    KeyName := Hotkey := A_ThisHotkey

Hotkey_Put:
    OnlyMods := 0
    K.Prefix := K.PLCtrl K.PRCtrl K.PLAlt K.PRAlt K.PLShift K.PRShift K.PLWin K.PRWin K.PCtrl K.PAlt K.PShift K.PWin
    Hotkey_Value(Hotkey_ID(ControlHandle), K.Prefix Hotkey), Hotkey_Value(ControlHandle, K.Prefix Hotkey)
    K.Mods := K.MLCtrl K.MRCtrl K.MLAlt K.MRAlt K.MLShift K.MRShift K.MLWin K.MRWin K.MCtrl K.MAlt K.MShift K.MWin
    Text := K.Mods KeyName = "" ? Hotkey_Arr("Empty") : K.Mods KeyName
    SendMessage, 0xC, 0, &Text, , ahk_id %ControlHandle%
    if Hotkey_Group("Get", Hotkey_ID(ControlHandle)) && Hotkey_Group("SaveCheck", ControlHandle)
        SetTimer, Hotkey_Group, -70
    return

Hotkey_Clear:
    OnlyMods := 0, K := {}
    Hotkey_Value(Hotkey_ID(ControlHandle), " "), Hotkey_Value(ControlHandle, " ")
    Text := Hotkey_Arr("Empty")
    SendMessage, 0xC, 0, &Text, , ahk_id %ControlHandle%
    if Hotkey_Group("Get", Hotkey_ID(ControlHandle)) && Hotkey_Group("SaveCheck", ControlHandle)
        SetTimer, Hotkey_Group, -70
    return
}

Hotkey_InitHotkeys() {
    static nmMods := "LAlt|RAlt|LCtrl|RCtrl|LShift|RShift|LWin|RWin"
    , nmMouse := "MButton|WheelDown|WheelUp|WheelRight|WheelLeft|XButton1|XButton2"
    , scSymb := "2|3|4|5|6|7|8|9|A|B|C|D|10|11|12|13|14|15|16|17|18|19|1A|1B|"
        . "1E|1F|20|21|22|23|24|25|26|27|28|29|2B|2C|2D|2E|2F|30|31|32|33|34|35"
    ; , scNumSymb := "53|52|4F|50|51|4B|4C|4D|47|48|49"
    , scOther := "1|E|F|1C|37|39|3A|3B|3C|3D|3E|3F|40|41|42|43|44|45|46|4A|4E|54|57|58|63|64|65|"
        . "66|67|68|69|6A|6B|6C|6D|6E|76|11C|135|147|148|149|14B|14D|14F|150|151|152|153|15D"
    , vkNum := "2E|6E|60|2D|61|23|62|28|63|22|64|25|65|C|66|27|67|24|68|26|69"
    , vkOther := "3|13|5F|A6|A7|A8|A9|AA|AB|AC|AD|AE|AF|B0|B1|B2|B3|B4|B5|B6|B7"
    S_BatchLines := A_BatchLines
    SetBatchLines, -1
    #IF Hotkey_IsRegControl()
    #IF Hotkey_Hook("K")
    #IF Hotkey_Hook("M")
    #IF Hotkey_Hook("L") && Hotkey_HasKeyboardModifier()
    #IF Hotkey_Hook("R") && Hotkey_HasKeyboardModifier()
    #IF Hotkey_Hook("J") && !Hotkey_Main("GetMod")
    #IF Hotkey_Arr("Hook") && !Hotkey_Hook("K")
    #IF
    Hotkey, IF, Hotkey_Hook("M")
    Loop, Parse, nmMouse, |
        Hotkey, % A_LoopField, Hotkey_View
    Hotkey, IF, Hotkey_Hook("K")
    Loop, Parse, nmMods, |
    {
        Hotkey, % A_LoopField, Hotkey_Mods
        Hotkey, % A_LoopField " Up", Hotkey_ModsUp
    }
    Loop, Parse, scSymb, |
        Hotkey, % "sc" A_LoopField, Hotkey_ViewSC
    Loop, Parse, scOther, |
        Hotkey, % GetKeyName("sc" A_LoopField), Hotkey_View
    Loop, Parse, vkNum, |
        Hotkey, % "vk" A_LoopField, Hotkey_ViewNum
    Loop, Parse, vkOther, |
        Hotkey, % GetKeyName("vk" A_LoopField), Hotkey_View
	Hotkey, IF, Hotkey_Hook("L") && Hotkey_HasKeyboardModifier()
    Hotkey, LButton, Hotkey_View
    Hotkey, IF, Hotkey_Hook("R") && Hotkey_HasKeyboardModifier()
    Hotkey, RButton, Hotkey_View
    S_FormatInteger := A_FormatInteger
    SetFormat, IntegerFast, D
    Hotkey, IF, Hotkey_Hook("J") && !Hotkey_Main("GetMod")
    Loop, 128
        Hotkey % Ceil(A_Index / 32) "Joy" Mod(A_Index - 1, 32) + 1, Hotkey_View
    SetFormat, IntegerFast, %S_FormatInteger%
    Hotkey, IF, Hotkey_IsRegControl()
    Hotkey, RButton, Hotkey_RButton
    Hotkey, RButton Up, Hotkey_Return
    Hotkey, IF, Hotkey_Arr("Hook") && !Hotkey_Hook("K")
    Hotkey, AppsKey Up, Hotkey_Return
    Hotkey, +F10, Hotkey_Return
    Hotkey, IF
    SetBatchLines, %S_BatchLines%
    return

    Hotkey_RButton:
        Click
    Hotkey_Return:
        return
}

Hotkey_IsRegControl() {
    MouseGetPos,,,, Control, 2
    return Hotkey_ID(Control) != ""
}

Hotkey_IsMouseInput(Key) {
    static MouseInputs := "|LButton|RButton|MButton|WheelDown|WheelUp|WheelRight|WheelLeft|XButton1|XButton2|"
    return InStr(MouseInputs, "|" Key "|")
}

Hotkey_HasKeyboardModifier() {
    return GetKeyState("Ctrl", "P") || GetKeyState("Shift", "P")
        || GetKeyState("Alt", "P") || GetKeyState("LWin", "P")
        || GetKeyState("RWin", "P")
}

Hotkey_SyncPhysicalModifiers(K) {
    static Modifiers := { LCtrl: "<^", RCtrl: ">^", LAlt: "<!", RAlt: ">!"
                        , LShift: "<+", RShift: ">+", LWin: "<#", RWin: ">#" }
    for Name, Prefix in Modifiers {
        IsDown := GetKeyState(Name, "P")
        K["M" Name] := IsDown ? Name "+" : ""
        K["P" Name] := IsDown ? Prefix : ""
    }
    K.MCtrl := K.MAlt := K.MShift := K.MWin := ""
    K.PCtrl := K.PAlt := K.PShift := K.PWin := ""
}

Hotkey_IsRegFocus() {
    ControlGetFocus, ControlNN, A
    ControlGet, hFocus, Hwnd, , %ControlNN%, A
    Hotkey_ID(hFocus) != "" ? Hotkey_Main("Control", hFocus) : 0
}

Hotkey_EventFocus(hWinEventHook, event, hwnd) {
    Hotkey_ID(hwnd) != "" ? Hotkey_Main("Control", hwnd) : Hotkey_Main("Control")
}

Hotkey_SetWinEventHook(eventMin, eventMax, hmodWinEventProc, lpfnWinEventProc, idProcess, idThread, dwFlags) {
    return DllCall("SetWinEventHook" , "UInt", eventMin, "UInt", eventMax, "Ptr", hmodWinEventProc
            , "Ptr", lpfnWinEventProc, "UInt", idProcess, "UInt", idThread, "UInt", dwFlags, "Ptr")
}

; -------------------------------------- Save and get --------------------------------------

Hotkey_Arr(P*) {
    static Arr := {"Empty":"Нет"}
    return P.MaxIndex() = 1 ? Arr[P[1]] : (Arr[P[1]] := P[2])
}

Hotkey_ID(P*) {
    static Arr := {}
    return P.MaxIndex() = 1 ? Arr[P[1]] : P.MaxIndex() = 2 ? (Arr[P[1]] := P[2]) : Arr.Delete(P[1])
}

Hotkey_Value(P*) {
    static Arr := {}
    return P.MaxIndex() = 1 ? Arr[P[1]] : P.MaxIndex() = 2 ? (Arr[P[1]] := P[2]) : Arr.Delete(P[1])
}

Hotkey_Options(P*) {
    static Arr := {}
    return P.MaxIndex() = 1 ? Arr[P[1]] : P.MaxIndex() = 2 ? (Arr[P[1]] := P[2]) : Arr.Delete(P[1])
}

Hotkey_ChangeOption(ID, Option) {
    (ID + 0 = "") ? (Hwnd := Hotkey_ID(ID), Name := ID) : (Hwnd := ID, Name := Hotkey_ID(ID))
    if RegExMatch(Hotkey_Options(Hwnd), "i)G(\d+)", g)
        Hotkey_Group("Delete", Name)
    if RegExMatch(Option, "i)G(\d+)", g)
        Hotkey_Group("Set", Name, g1)
    return Hotkey_Options(Hwnd, Option)
}

Hotkey_Hook(Option) {
    return Hotkey_Arr("Hook") && !!InStr(Hotkey_Arr("Hook"), Option)
}

Hotkey_Delete(ID, Destroy = 0) {
    (ID + 0 = "") ? (Hwnd := Hotkey_ID(ID), Name := ID) : (Hwnd := ID, Name := Hotkey_ID(ID))
    Hotkey_Group("Delete", Name)
    Hotkey_ID(Hwnd, "", 1), Hotkey_ID(Name, "", 1)
    Hotkey_Value(Hwnd, "", 1), Hotkey_Value(Name, "", 1)
    Hotkey_Options(Hwnd, "", 1)
    ControlGetFocus, ControlNN, A
    ControlGet, hFocus, Hwnd, , %ControlNN%, A
    (hFocus = Hwnd ? Hotkey_Main("Control") : 0)
    if Destroy
        DllCall("DestroyWindow", "Ptr", Hwnd)
    else
        PostMessage, 0x00CF, 0, , , % "ahk_id" Hwnd		;  EM_SETREADONLY
    return Hwnd
}

Hotkey_Set(Name, Value = "") {
    Text := Hotkey_HKToStr(Value)
    SendMessage, 0xC, 0, &Text, , % "ahk_id" Hotkey_ID(Name)
    return Text, Hotkey_Value(Name, Value), Hotkey_Value(Hotkey_ID(Name), Value)
}

Hotkey_Read(Name, Section = "", FilePath = "") {
    HK := Hotkey_IniRead(Name, Section, FilePath), Hotkey_Value(Name, HK)
    return Hotkey_HKToStr(HK)
}

Hotkey_IniPath(Path = "") {
    return Path = "" ? Hotkey_Arr("IniPath") : Hotkey_Arr("IniPath", Path)
}

Hotkey_IniSection(Section = "") {
    return Section = "" ? Hotkey_Arr("IniSection") : Hotkey_Arr("IniSection", Section)
}

Hotkey_IniRead(Name, Section = "", FilePath = "") {
    IniRead, Data, % FilePath = "" ? Hotkey_IniPath() : FilePath, % Section = "" ? Hotkey_IniSection() : Section, % Name, % A_Space
    return Data
}

Hotkey_IniWrite(ID, Section = "", FilePath = "") {
    Key := (ID + 0 = "") ? ID : Hotkey_ID(ID)
    if (Key != "")
        IniWrite, % Hotkey_Value(ID), % FilePath = "" ? Hotkey_IniPath() : FilePath, % Section = "" ? Hotkey_IniSection() : Section, % Key
}

; -------------------------------------- Group --------------------------------------

Hotkey_Group(Key = "", p1 = "", p2 = "") {
    static NG := {}, GN := [], Blink := [], SaveCheck := [], i := 0
    if (Key = "") {
        for k, Name in SaveCheck {
            if ((Value := Hotkey_Value(Name)) != "") {
                (f := Hotkey_Arr("GroupEvents")) != "" && (r := {}, r.names := [])
                for m, n in GN[NG[Name]] {
                    if (n != Name && Hotkey_Equal(Value, Hotkey_Value(n))) {
                        Hotkey_Set(Name)
                        (f != "") && (r.names.Push(n), r.this := Name, r.value := Value, r.group := NG[Name])
                        if !DllCall("IsWindowVisible", "Ptr", Hotkey_ID(n))
                            continue
                        DllCall("ShowWindowAsync", "Ptr", Hotkey_ID(n), "Int", 0)
                        Blink[Hotkey_ID(n)] := 1, i := 3
                        SetTimer, Hotkey_BlinkControl, -50
                    }
                }
            }
            SaveCheck.Delete(k)
        }
        (f != "") && (r.this != "") && %f%(r)
    }
    else if (Key = "Set")
        NG[p1] := p2, IsObject(GN[p2]) ? GN[p2].Push(p1) : GN[p2] := [p1]
    else if (Key = "SaveCheck")
        return 1, SaveCheck[p1] := Hotkey_ID(p1)
    else if (Key = "Get")
        return NG[p1] != ""
    else if (Key = "CheckAll") {
        for k, v in GN {
            for k, n in v {
                if ((Value := Hotkey_Value(n)) != "") {
                    for k, m in v {
                        if (n != m && Hotkey_Equal(Value, Hotkey_Value(m)))
                            Hotkey_Set(m)
					}
				}
			}
		}
    }
    else if (Key = "Delete") {
        for k, v in GN[NG[p1]] {
            if (v = p1) {
                GN[NG[p1]].RemoveAt(k)
                break
            }
		}
        NG.Delete(p1)
    }
    return

    Hotkey_BlinkControl:
        for k in Blink
            DllCall("ShowWindowAsync", "Ptr", k, "Int", Mod(i, 2) ? 4 : 0)
        if (--i > 0) || !(Blink := [])
            SetTimer, Hotkey_BlinkControl, -50
        return
}

Hotkey_Equal(HK1, HK2) {
    if (HK2 = "")
        return 0
    if (HK1 = HK2)
        return 1
    if !(HK1 ~= "S)[\^\+!#]") || !(HK2 ~= "S)[\^\+!#]")
        return 0
    if (HK1 ~= "S)[<>]") && (HK2 ~= "S)[<>]")
        return 0
    return (Hotkey_ModsSub(HK1) = Hotkey_ModsSub(HK2))
}

Hotkey_ModsSub(Value) {
    if !(Value ~= "[<>]")
        return Value
    Value := StrReplace(Value, "<")
    Value := StrReplace(Value, ">")
    Value := StrReplace(Value, "^^", "^", , 1)
    Value := StrReplace(Value, "!!", "!", , 1)
    Value := StrReplace(Value, "++", "+", , 1)
    return StrReplace(Value, "##", "#", , 1)
}

; -------------------------------------- Format --------------------------------------

; http://forum.script-coding.com/viewtopic.php?pid=105023#p105023

Hotkey_HKToStr(HK) {
    static LRPrefix := [["<^","LCtrl"],[">^","RCtrl"],["<!","LAlt"],[">!","RAlt"]
                    ,["<+","LShift"],[">+","RShift"],["<#","LWin"],[">#","RWin"]]
    , Prefix := [["^","Ctrl"],["!","Alt"],["+","Shift"],["#","Win"]]
    , EngSym := {"sc2":"1","sc3":"2","sc4":"3","sc5":"4","sc6":"5","sc7":"6"
                ,"sc8":"7","sc9":"8","scA":"9","scB":"0","scC":"-","scD":"="
                ,"sc10":"Q","sc11":"W","sc12":"E","sc13":"R","sc14":"T","sc15":"Y"
                ,"sc16":"U","sc17":"I","sc18":"O","sc19":"P","sc1A":"[","sc1B":"]"
                ,"sc1E":"A","sc1F":"S","sc20":"D","sc21":"F","sc22":"G","sc23":"H"
                ,"sc24":"J","sc25":"K","sc26":"L","sc27":"`;","sc28":"'","sc29":"``"
                ,"sc2B":"\","sc2C":"Z","sc2D":"X","sc2E":"C","sc2F":"V","sc30":"B"
                ,"sc31":"N","sc32":"M","sc33":",","sc34":".","sc35":"/"

                ,"vk31":"1","vk32":"2","vk33":"3","vk34":"4","vk35":"5","vk36":"6"
                ,"vk37":"7","vk38":"8","vk39":"9","vk30":"0","vkBD":"-","vkBB":"="
                ,"vk51":"Q","vk57":"W","vk45":"E","vk52":"R","vk54":"T","vk59":"Y"
                ,"vk55":"U","vk49":"I","vk4F":"O","vk50":"P","vkDB":"[","vkDD":"]"
                ,"vk41":"A","vk53":"S","vk44":"D","vk46":"F","vk47":"G","vk48":"H"
                ,"vk4A":"J","vk4B":"K","vk4C":"L","vkBA":"`;","vkDE":"'","vkC0":"``"
                ,"vkDC":"\","vk5A":"Z","vk58":"X","vk43":"C","vk56":"V","vk42":"B"
                ,"vk4E":"N","vk4D":"M","vkBC":",","vkBE":".","vkBF":"/"}

    RegExMatch(HK, "S)^\s*([~\*\$\^\+!#<>]*)\{?(.*?)}?\s*$", K)
    if (K2 = "")
        return "" Hotkey_Arr("Empty")
    if (InStr("|" K2, "|sc") || InStr("|" K2, "|vk"))
        K2 := Hotkey_Arr("OnlyEngSym") && EngSym.HasKey(K2) ? EngSym[K2] : GetKeyName(K2)
    if (K1 != "")
        for I, V in K1 ~= "[<>]" ? LRPrefix : Prefix
            K1 := StrReplace(K1, V[1], "", R), R && (M .= V[2] "+")
    return M . (StrLen(K2) = 1 ? Format("{:U}", K2) : K2)
}

Hotkey_HKToSend(HK, Section = "", FilePath = "") {
    static LRPrefix := [["<^","LCtrl"],[">^","RCtrl"],["<!","LAlt"],[">!","RAlt"]
                       ,["<+","LShift"],[">+","RShift"],["<#","LWin"],[">#","RWin"]]
         , Prefix := [["^","LCtrl"],["!","LAlt"],["+","LShift"],["#","LWin"]]
    if (HK = "")
        return
    if (Section != "")
        IniRead, HK, % FilePath = "" ? Hotkey_IniPath() : FilePath, % Section, % HK, % A_Space
    RegExMatch(HK, "S)^\s*([~\*\$\^\+!#<>]*)\{?(.*?)}?\s*$", K)
    if (K1 != "") {
        for I, V in K1 ~= "[<>]" ? LRPrefix : Prefix {
            K1 := StrReplace(K1, V[1], "", R)
            , R ? (M1 .= "{" V[2] " Down}", M2 .= "{" V[2] " Up}") : 0
		}
	}
    return M1 . "{" K2 "}" . M2
}

#if WinExist("ScreenShot ahk_class AutoHotkeyGUI")
#if

#if IsOverlaySelectionState("armed")
LButton:: BeginOverlaySelectionDrag()
RButton:: CancelOverlaySelection()
Esc:: CancelOverlaySelection()
#if

#if IsOverlaySelectionState("dragging")
*LButton Up:: FinishOverlaySelection()
RButton:: CancelOverlaySelection()
Esc:: CancelOverlaySelection()
#if

#if IsSelectionWindowActive()
^WheelUp::   NudgeSelectionEdge("Left"  , -1)
^WheelDown:: NudgeSelectionEdge("Left"  ,  1)
+WheelUp::   NudgeSelectionEdge("Top"   , -1)
+WheelDown:: NudgeSelectionEdge("Top"   ,  1)
!WheelUp::   NudgeSelectionEdge("Right" ,  1)
!WheelDown:: NudgeSelectionEdge("Right" , -1)
#WheelUp::   NudgeSelectionEdge("Bottom", -1)
#WheelDown:: NudgeSelectionEdge("Bottom",  1)
#if

#if WinActive("ScreenShot ahk_class AutoHotkeyGUI")
Esc:: PostMessage, Esc,,,, A
*WheelDown::
*WheelUp:: PostMessage, Wheel, A_ThisHotkey = "*WheelUp" ? 0 : 1,,, A
#if

class Tool_Tip
{
  ; #requires AutoHotkey v2.0.19
  ; Tool_Tip by Alectric
  ; https://forum.script-coding.com/
  ; Метод 	Show(Text:="",X:="",Y:="",Delay:=0,Trans:="",BackColor:="",Font:="",FontName:="",WW:=0,HH:=0)
  ; 	Text		- Текст который необходимо отобразить
  ; 	X, Y		- Координаты появления относительно экрана
  ; 	Delay		- задержка пропадания после вызова в миллисекундах
  ; 	Trans		- Прозрачность в формате AHK Gui (но от 2 до 255), false - не прозрачно, true - прозрачность=180; (также становится прозрачен для кликов мыши)
  ; 	BackColor	- Цвет фона
  ; 	Font		- Параметры шрифта в формате Gui (цвет, размер, наклон, толщина, подчеркнутый, зачеркнутый)
  ; 	FontName	- Название шрифта
  ; 	WW, HH		- Фиксированные ширина и высота (если оба значения не 0, то отрисовка в ~5 раз быстрее)
  ;
  ; Метод Hide()	- Скрывает Tooltip
  ;
  ; Свойство Pos	- Возвращает объект с параметрами окна {X:X,Y:Y,W:W,H:H}.

  static DPICoef:=Tool_Tip.GetDPICoef()

  __Delete()
  {
    ObjAddRef(ObjPtr(this))
    SetTimer this.obm,0
    this.TTW.Destroy()
    this.obm:=unset
;    tooltip "Деструктор вызван"
;    sleep 1000
;    tooltip
  }

  __New()
  {
    this.Visible:=false
    this.X:=0
    this.Y:=0
    this.W:=0
    this.H:=0
    this.BackColor:="0xFFFFFF"
    this.Trans:=255
    this.Text:=""
    this.Font:="s9"
    this.FontName:="Arial"
    this.TTW:=Gui("+ToolWindow -sysmenu -Resize +AlwaysOnTop -Caption +Border +E0x2080000")
    this.TTW.SetFont(this.Font,this.FontName)
    this.TTW.BackColor:=this.BackColor
    this.TTW.MarginX:=2
    this.TTW.MarginY:=2
    this.TTT:=this.TTW.Add("Text")
    this.obm:=ObjBindMethod(this,"Hide")
    ObjRelease(ObjPtr(this))
    this.TTW.OnEvent("ContextMenu",this.obm)
    this.TTT.OnEvent("Click",this.obm)
  }

  Pos
  {
    get
    {
      this.TTW.GetPos(&X,&Y,&W,&H)
      return {X:X,Y:Y,W:W,H:H}
    }
  }

  Hide(*)
  {
    this.TTW.Hide()
    this.Visible:=false
  }

  Show(Text:="",X:="",Y:="",Delay:=0,Trans:="",BackColor:="",Font:="",FontName:="",WW:=0,HH:=0)
  {
    SaveCoordMode:=A_CoordModeMouse
    CoordMode "Mouse","Screen"
    MouseGetPos(&mX,&mY,&mW,&mC,2)
    CoordMode "Mouse",SaveCoordMode
    if (X="")
      X:=mX+10
    if (Y="")
      Y:=mY+20
    if ((Font!="" and Font!=this.Font) or (FontName!="" and FontName!=this.FontName))
    {
      this.Font:=Font
      this.FontName:=FontName
      this.TTT.SetFont(this.Font,this.FontName)
    }
    W:=this.W
    H:=this.H
    if (Text!="" and Text!=this.Text)
    {
      this.Text:=Text
      if (!WW or !HH)
      {
        ControlSetStyle("-1",this.TTT)
        Size:=this.Measure(Text)
      }
      else
      {
        ControlSetStyle("+1",this.TTT)
        Size:={X:X,Y:Y,W:WW,H:HH}
      }
      this.TTT.Move(,,Size.W,Size.H)
      this.TTT.Value:=Text
      W:=Size.W+8
      H:=Size.H+8
    }
    B:=this.Bound(X,Y,W,H)
    W:=Round(W/Tool_Tip.DPICoef)
    H:=Round(H/Tool_Tip.DPICoef)
    X:=B.X
    Y:=B.Y
    if (X!=this.X or Y!=this.Y or W!=this.W or H!=this.H or BackColor!=this.BackColor or !this.Visible)
    {
      this.X:=X
      this.Y:=Y
      this.W:=W
      this.H:=H
      this.Visible:=true
      if (BackColor!="" and BackColor!=this.BackColor)
      {
        this.BackColor:=BackColor
        this.TTW.BackColor:=BackColor
      }
      this.TTW.show("x" X " y" Y " w" W " h" H " NoActivate")
    }
    if (Trans!="" and Trans!=this.Trans)
    {
      this.Trans:=Trans
      if Trans
      {
        WinSetTransparent(Trans=1?180:Trans,this.TTW)
        WinSetExStyle("+0x20",this.TTW)
      }
      else
      {
        WinSetTransparent(255,this.TTW)
        WinSetExStyle("-0x20",this.TTW)
      }
    }
    SetTimer this.obm,-abs(Delay)
  }

  Measure(Text)
  {
    G:=Gui()
    G.SetFont(this.Font,this.FontName)
    G.MarginX:=2
    G.MarginY:=2
    T:=G.Add("Text",,Text)
    Controlgetpos(&X,&Y,&W,&H,T)
    G.Destroy()
    return {X:X,Y:Y,W:W,H:H}
  }

  Bound(X,Y,W:=0,H:=0)
  {
    this.last:=1
    Loop MonitorGetCount()
    {
      MonitorGet(A_Index,&Left,&Top,&Right,&Bottom)
      if (X>=Left and X<=Right and Y>=Top and Y<=Bottom)
      {
        MonitorGetWorkArea(A_Index,&Left,&Top,&Right,&Bottom)
        this.last:=a_index
        return {X:(X+W>Right?Right-W:X)
               ,Y:(Y+H>Bottom?Bottom-H:Y)
               ,B:a_index}
      }
    }
    MonitorGetWorkArea(this.last,&Left,&Top,&Right,&Bottom)
    return {X:(X+W>Right?Right-W:X<Left?Left:X)
           ,Y:(Y+H>Bottom?Bottom-H:Y<Top?Top:Y)
           ,B:this.last}
  }

  static GetDPICoef()
  {
    G:=Gui()
    T:=G.Add("Text","x0 y0 w1000 h1000")
    Controlgetpos(,,&W,,T)
    G.Destroy()
    return W/1000
  }
}

arr3:=[]
loop 7
  arr3.Push([])
c:=1
d:=0
e:=1
a:=0
t:=0
b:=0
arr:=[]

settimer ddd,150
settimer aaa,500

gra:=Graph()
gra.show()

gra.ArrName[1]:="кг"
gra.ArrName[2]:="Двигатель"
gra.ArrName[3]:="Температура"
gra.ArrName[4]:="Разряжение"
gra.ArrName[5]:="Натяжение"
gra.ArrName[6]:="Угол"
gra.ArrName[7]:="Ничего"

gra.DataArray:=arr3

d:=e:=-1300

f1::
{
  gra.show()
}

f2::
{
  if (gra.DataArray=arr3)
    gra.DataArray:=arr
  else
    gra.DataArray:=arr3
}

ddd()
{
  global
  a+=0.1
  if (b<-1 or b>1)
    t:=!t
  if t
    b+=0.005
  else
    b-=0.005
  if (b>1)
  {
    d:=random(-1000000000,1000000000)
    e:=random(-1000000000,1000000000)
    c:=random(0.5,1.5)
  }
  var:=random(50.5,100.5)
  shift:=0
  Val:=(sin(a)*var*b+shift)

  arr.Push(sin(a))

  arr3[1].Push(Val-30)
  arr3[4].Push([Val,A_Now,A_MSec])
  arr3[3].Push([-Val,A_Now,A_MSec])
  arr3[5].Push([cos(a*a)*0.1,A_Now,A_MSec])
  arr3[6].Push([cos(-a*2)*10*b+10,A_Now,A_MSec])
  arr3[7].Push([random(-1000000000,1000000000),A_Now,A_MSec])
}

aaa()
{
  static bool:=1
  bool:=!bool
  arr3[2].Push([bool,A_Now,A_MSec])

}

Esc::
{
global
gra:=""
exitapp
}

class Graph
{
  ; #requires AutoHotkey v2.0.19
/*
Graph by Alectric
https://forum.script-coding.com/

Метод Call(Name:="",UpdatePeriod:=50)
	Создает экземпляр объекта.
	Name - имя будущего окна графика.
	UpdatePeriod - период обновления графика в окне, в миллисекундах.

Свойство DataArray - принимает массив с данными для отображения.
	Принимает следующие варианты массива:
		простой массив с данными; [ 1, 2, 3, ...]
		массив данных с меткой времени в формате AHK (YYYYMMDDHH24MISS); [ [1,20230510200000], [2,20230510200001], ...]
		массив с меткой времени с миллисекундами; [ [1,20230510200000,123], [2,20230510200001,432], ...]
		массив массивов выше перечисленных типов.

Свойство Pause - если true - останавливает прокрутку графика в реальном времени.
Метод MenuForward() - отключает паузу прокрутки и переносит отображение на самые свежие данные в массиве.
Метод MenuBackward() - включает паузу прокрутки и переносит отображение на самые старые данные в массиве.

Свойство Num - возвращает количество графиков в окне.
Свойство Select - задает/возвращает номер "выбранного" графика, если графиков больше чем один.
Свойство ArrName[n] - (строка) задает имя графику под номером n.
	Изначально данный массив содержит 10 элементов, на случай, если необходимо прописать имена раньше, чем привязать массив с данными. Используйте Push для расширения.

Метод MenuAutoScale() - переключает режим масштабирования "выбранного" графика между автоматическим и ручным.
Свойство AScale - задает режим масштабирования "выбранного" графика между автоматическим и ручным (true/false) {не работает до добавления массива с данными}.
Свойство AutoScale[n] - задает режим масштабирования графика n между автоматическим и ручным (true/false) {не работает до добавления массива с данными}.
Свойство ScaleY - задает масштаб шкалы "выбранного" графика, отключает авто-масштаб {не работает до добавления массива с данными}.
Свойство YScale[n] - задает масштаб шкалы графика n, авто-масштаб отключайте вручную {не работает до добавления массива с данными}.
Свойство ScaleX - задает масштаб по горизонтали: в миллисекундах (если отрисовка по времени) или в количестве точек (если отрисовка по точкам)
Свойство OScale - задает общий масштаб шкалы по вертикали (true/false).

Метод MenuScaleXByTime() - включает режим отрисовки графиков по времени.
Метод MenuScaleXByDots() - включает режим отрисовки графиков по точкам.

Метод MenuSmooth() - переключает режим сглаживания "выбранного" графика {не работает до добавления массива с данными}.
Свойство Smth - задает режим сглаживания "выбранного" графика (true/false) {не работает до добавления массива с данными}.
Свойство Smooth[n] - задает режим сглаживания графика n (true/false) {не работает до добавления массива с данными}.
Свойство Transparence - задает прозрачность "выбранного" графика (0-прозрачен, 255-видим) {не работает до добавления массива с данными}.
Свойство Colour - задает цвет без альфа-канала и оттенок фона текста "выбранного" графика {не работает до добавления массива с данными}.
Свойство Pen[n] - задает цвет с альфа-каналом графика n (0xaabbccdd, где: aa-прозрачность, bb-красный, cc-зеленый, dd-синий) {не работает до добавления массива с данными}.
Свойство Hue[n] - задает оттенок фона текста графика n {не работает до добавления массива с данными}.

Метод MenuAlwaysOnTop() - переключает режим "всегда поверх окон" для окна графика.
Свойство OnTop - задает режим "всегда поверх окон" для окна графика (true/false).

Метод MenuSave() - выводит диалог выбора файла чтобы сохранить график.
Метод MenuLoad() - выводит диалог выбора файла из которого загрузить файл графика.
Метод LoadFile(File) - загружает файл графика по пути "File" (!Путь не проверяется на корректность!).

Свойство Name - задает имя окна графика, после изменения этого свойства необходимо вызвать метод Show.
Свойство UpdatePeriod - задает период обновления окна графика, после изменения этого свойства необходимо вызвать метод Show.
Метод Show(x:="",y:="",w:="",h:="",NewName:="",NewUP:="")
	- отображает окно графика с необходимыми координатами (если заданы)
	- новым именем окна (если задано NewName)
	- и новым периодом обновления окна (если задан NewUP).
Метод Hide() - скрывает окно графика, и отключает отрисовку, чтобы снять нагрузку с процессора.

Метод MenuResetFont() - сбрасывает настройки размера шрифта отрисовки.
Метод SetFont(Font:="",Size:="",fStyle:="",NoWrap:="",RenderingHint:="",Vertical:="")
	Задает параметры шрифта отрисовки графика.
	Font - имя шрифта (Arial, Lucida Console, ...)
	Size - размер шрифта.
	fStyle - стиль шрифта (Regular|Bold|Italic|BoldItalic|Underline|Strikeout)
	NoWrap - режим переноса текста на следующую строку. (в контексте класса бесполезное свойство)
	RenderingHint - режим рендеринга текста.
		SystemDefault = 0
		SingleBitPerPixelGridFit = 1
		SingleBitPerPixel = 2
		AntiAliasGridFit = 3
		AntiAlias = 4
	Vertical - делает текст вертикальным (в контексте класса бесполезное свойство)

Сопутствующие функции (описаны в конце класса Graph):
	Горячие клавиши для изменения масштабирования:
		WheelUp
		WheelDown
	Функции выбора цвета:
		  Windows Color Picker Plus
		  https-//autohotkey.com/board/topic/91229-windows-color-picker-plus/
		ChooseColor(pRGB:=0,hOwner:=0,DlgX:=0,DlgY:=0)
		ColorWindowProc(hwnd, msg, wParam, lParam)
		BGR2RGB(Color)
	Функции загрузки/сохранения файла:
		ObjLoad(addr,&offset:=0) ; load dumped object to variable; from memory (addr is int) or from file (addr is string)
		ObjDump(Path,obj) ; dump object to file
		RawObject(obj,ptr,offset:=0) ; dump object to memory
		RawObjectSize(Obj,sz:=0) ; get object's size in dumped condition
*/

  static hModule:=DllCall("LoadLibrary","str","gdiplus","Ptr")
  static pToken:=0, InstanceCount:=0
  static WinText:="Special text to identify the ownership of the Graph window."
  ;gdiplus\
  static hGdipCreateFont:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipCreateFont","Ptr")
  static hGdipCreateFontFamilyFromName:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipCreateFontFamilyFromName","Ptr")
  static hGdipCreateFromHDC:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipCreateFromHDC","Ptr")
  static hGdipCreatePen1:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipCreatePen1","Ptr")
  static hGdipCreateSolidFill:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipCreateSolidFill","Ptr")
  static hGdipCreateStringFormat:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipCreateStringFormat","Ptr")
  static hGdipDeleteBrush:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipDeleteBrush","Ptr")
  static hGdipDeleteFont:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipDeleteFont","Ptr")
  static hGdipDeleteFontFamily:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipDeleteFontFamily","Ptr")
  static hGdipDeletePen:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipDeletePen","Ptr")
  static hGdipDeleteStringFormat:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipDeleteStringFormat","Ptr")
  static hGdipDrawEllipse:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipDrawEllipse","Ptr")
  static hGdipDrawLine:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipDrawLine","Ptr")
  static hGdipDrawLines:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipDrawLines","Ptr")
  static hGdipDrawString:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipDrawString","Ptr")
  static hGdipFillRectangle:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipFillRectangle","Ptr")
  static hGdiplusShutdown:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdiplusShutdown","Ptr")
  static hGdiplusStartup:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdiplusStartup","Ptr")
  static hGdipMeasureString:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipMeasureString","Ptr")
  static hGdipSetSmoothingMode:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipSetSmoothingMode","Ptr")
  static hGdipSetStringFormatAlign:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipSetStringFormatAlign","Ptr")
  static hGdipSetTextRenderingHint:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipSetTextRenderingHint","Ptr")
  static hGdipReleaseDC:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipReleaseDC","Ptr")
  static hGdipDeleteGraphics:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipDeleteGraphics","Ptr")
  static hGdipCreateBitmapFromHBITMAP:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipCreateBitmapFromHBITMAP","Ptr")
  static hGdipCreateTexture2:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipCreateTexture2","Ptr")
  static hGdipDisposeImage:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipDisposeImage","Ptr")
  static hGdipDrawRectangle:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipDrawRectangle","Ptr")

  static min:=-9223372036854775808
  static max:= 9223372036854775807
  static MaxTime:=30*24*3600000 ; миллисекунд
  static WheelUp:=false
  static WheelDown:=false
  static HotKeymW:=0

  __Delete()
  {
    if !this.Exist
      return
    this.Exist:=false
    loop this.RefCount
      ObjAddRef(ObjPtr(this))
;    tooltip "Деструктор вызван.`n" Graph.InstanceCount "`n" this.Name
;    sleep 1000
;    tooltip
    settimer this.UpdateTimer,0
    this.UpdateTimer:=""
    DllCall(Graph.hGdipDeleteGraphics,"UPtr",this.pGraphics)
    DllCall("SelectObject","Ptr",this.hDC,"Ptr",this.obm)
    DllCall("DeleteObject","UPtr",this.hBitmap)
    DllCall("ReleaseDC","Ptr",this.GuiGDIP.Hwnd,"Ptr",this.hDC)
    this.GuiHelp.Destroy()
    this.GuiGoToT.Destroy()
    this.GuiGDIP.Destroy()
    this.GuiGraph.Destroy()
    this.GraphMenu.Delete()
    this.GraphMenuSettings.Delete()
    loop this.Child.Length
    {
      ObjAddRef(ObjPtr(this))
      this.Child[a_index]:=""
    }
    Graph.InstanceCount--
    if (Graph.InstanceCount=0)
    {
      DllCall(Graph.hGdiplusShutdown,"Ptr",Graph.pToken)
      Graph.pToken:=""
    }
  }

  mi:={MenuAlwaysOnTop:"Всегда поверх окон"
  ,MenuAutoScale:"Автомасштаб"
  ,MenuSmooth:"Сглаживать ступеньки"
  ,MenuFlFt:"Количество знаков после запятой..."
  ,MenuUpdPrd:"Период обновления графика..."
  ,MenuScaleXByTime:"Масштабировать X по времени"
  ,MenuScaleXByDots:"Масштабировать X по точкам"
  ,MenuResetFont:"Сбросить размер шрифта"
  ,MenuGColor:"Выбрать цвет графика..."
  ,MenuName:"Изнменить имя выбранного графика..."
  ,MenuSave:"Сохранить график в файл..."
  ,MenuLoad:"Загрузить график из файла..."
  ,MenuClose:"Х "
  ,MenuPause:"(||)"
  ,MenuForward:"(>|)"
  ,MenuBackward:"(|<)"
  ,MenuGoTo:"Перейти"
  ,MenuMarkers:"Маркеры"
  ,MenuHelp:"Справка"
  ,Settings:"Настр."}

  __New(Name:="",UpdatePeriod:=50)
  {
    ; Запустить библиотеку гдиплюс
    if !Graph.pToken
    {
      si:=Buffer(A_PtrSize=8 ? 24 : 16,0)
      NumPut("UChar",1,si,0)
      DllCall(Graph.hGdiplusStartup,"UPtr*",&pToken:=0,"Ptr",si.Ptr,"Ptr",0)
      Graph.pToken:=pToken
    }
    Graph.InstanceCount++

    this.Name:=Name
    if !Name
      this.Name:="График " Graph.InstanceCount

    ; Инициализация переменных

    this.ArrName:=[]
    loop 10
      this.ArrName.Push("")
    this.IsChild:=false
    this.Child:=[]
    this.Parent:=0
    this.Exist:=true
    this.SaveArrName:=[]
    this.SetParentOnce:=false
    this.CreateTime:=[A_Now,A_msec]
    this.Data:=[]
    this.NewData:=""
    this.Loaded:=0
    this.FloatFormat:=3
    this.Drawing:=false
    this.UpdatePeriod:=UpdatePeriod
    this.hFormat:=0
    this.hFamily:=0
    this.hFont:=0
    this.prevRenderingHint:=""
    this.prevBrushColor:=0
    this.prevPenColor:=0
    this.prevNoWrap:=0
    this.prevVertical:=0
    this.prevFont:=""
    this.prevSize:=0
    this.prevfStyle:=""
    this.prevColour:=0
    this.pBrush:=0
    this.pPen:=0
    this.FontpBrush:=0
    this.GPosW:=0
    this.GPosH:=0
    this.GPosH_:=0
    this.Pause:=false
    this.OScale:=true

    this.GetmCoordOnce:=false
    this.GetStartPosRectOnce:=false

    this.ZoomX:=100
    this.ZoomT:=30000
    this.OldZoomX:=this.ZoomX
    this.OldZoomT:=this.ZoomT
    this.SaveZoomX:=this.ZoomX
    this.SaveZoomT:=this.ZoomT
    this.ShowZoomTip:=0
    this.XTOffset:=0
    this.X_Offset:=0
    this.ZeroPos:=30
    this.ZeroPosU:=1
    this.GPosH:=160

    this.AStartTime:=0
    this.StampOffset:=0
    this.MarkerOffset:=0
    this.StampsNum:=5
    this.XMarker:=[-9999,-9999]
    this.MenuOffset:=0
    this.Old_XTOffset:=0
    this.OldXTOffset:=0

    this.Sel:=1
    this.Proc:=0
    this.StartTime:=0
    this.OldmX:=0
    this.OldmY:=0
    this.FontpBrush:=0
    this.SaveStrt:=[0,0]
    this.ShowMarkers:=false
    this.OffsetSetting:=false
    this.ShiftStrt:=false
    this.MouseMoved:=false
    this.OldX_Offset:=0
    this.StampPos:={X:0,Y:0,W:0,H:this.GPosH,Chars:0,Lines:0}
    this.ETPos:={X:0,Y:0,W:0,H:0,Chars:0,Lines:0}
    this.TipPos:={X:0,Y:0,W:0,H:0,Chars:0,Lines:0}
    this.iZoomPos:={X:0,Y:0,W:0,H:0,Chars:0,Lines:0}
    this.OScalePos:={X:0,Y:0,W:0,H:0,Chars:0,Lines:0}
    this.Setting:=false
    this.RectZoom:=false
    this.XMarkerOnce:=false
    this.AlwaysOnTop:=false
    this.PrevW:=0
    this.PrevH:=0
    this.TimeOut:=false
    this.TOZoomX:=0
    this.TOZoomT:=0

    ; Создать графику
    this.Create()
    this.ReInit()

    ; Настройки по умолчанию
    this.Font:="Lucida Console" ; шрифт
    this.FontSize:=12 ; размер шрифта
    this.SetFont(this.Font,this.FontSize)
    this.Font_Colour:=0xff000000 ; цвет шрифта
    this.Font_Back:=0xd0ffffff ; цвет фона шрифта
    this.WhiteBrush:=0xffffffff ; для общего фона
    this.GrayPen:=0xaa808080 ; для оси
    this.GrayPen2:=0xaae0e0e0 ; для оси
    this.RedPen:=0xffff0000 ; для маркера
    this.LightGreenBrush:=0xffd5ffd5 ; для фона информации
    this.LightBlueBrush:=0xffd5d5ff ; для фона Меню
    this.BluePen:=0xff0000ff ; для графика

    s:=this.mi.MenuClose this.mi.MenuPause this.mi.MenuForward this.mi.MenuBackward this.mi.MenuGoTo this.mi.MenuMarkers this.mi.Settings this.mi.MenuHelp
    loop 12
      s.="_"
    w:=this.MeasureString(s,this.CreateRectF(0,0,1400,100))
    ; смещение исходной высоты если нет данных

    this.MessagePos:={X:0,Y:0,W:0,H:w.H,Chars:0,Lines:0}

; Добавление меню
    ; Меню настроек
    this.GraphMenuSettings:=Menu()

    obm:=ObjBindMethod(this,"MenuSave")
    this.GraphMenuSettings.add(this.mi.MenuSave,obm)

    obm:=ObjBindMethod(this,"MenuLoad")
    this.GraphMenuSettings.add(this.mi.MenuLoad,obm)

    this.GraphMenuSettings.add()

    obm:=ObjBindMethod(this,"MenuAlwaysOnTop")
    this.GraphMenuSettings.add(this.mi.MenuAlwaysOnTop,obm)

    obm:=ObjBindMethod(this,"MenuAutoScale")
    this.GraphMenuSettings.add(this.mi.MenuAutoScale,obm)
    this.GraphMenuSettings.check(this.mi.MenuAutoScale)

    obm:=ObjBindMethod(this,"MenuSmooth")
    this.GraphMenuSettings.add(this.mi.MenuSmooth,obm)
    this.GraphMenuSettings.check(this.mi.MenuSmooth)

    obm:=ObjBindMethod(this,"MenuFlFt")
    this.GraphMenuSettings.add(this.mi.MenuFlFt,obm)

    obm:=ObjBindMethod(this,"MenuUpdPrd")
    this.GraphMenuSettings.add(this.mi.MenuUpdPrd,obm)

    this.GraphMenuSettings.add()

    obm:=ObjBindMethod(this,"MenuScaleXByTime")
    this.GraphMenuSettings.add(this.mi.MenuScaleXByTime,obm,"+Radio")
    this.GraphMenuSettings.check(this.mi.MenuScaleXByTime)
    this.ScaleXByTime:=true

    obm:=ObjBindMethod(this,"MenuScaleXByDots")
    this.GraphMenuSettings.add(this.mi.MenuScaleXByDots,obm,"+Radio")

    this.GraphMenuSettings.add()

    obm:=ObjBindMethod(this,"MenuName")
    this.GraphMenuSettings.add(this.mi.MenuName,obm)

    obm:=ObjBindMethod(this,"MenuGColor")
    this.GraphMenuSettings.add(this.mi.MenuGColor,obm)

    obm:=ObjBindMethod(this,"MenuResetFont")
    this.GraphMenuSettings.add(this.mi.MenuResetFont,obm)

    ; основное меню
    this.GraphMenu:=MenuBar()
;    obm:=ObjBindMethod(this,"MenuClose")
;    this.GraphMenu.add(this.mi.MenuClose,obm)

    this.GraphMenu.add(this.mi.Settings,this.GraphMenuSettings)

    obm:=ObjBindMethod(this,"MenuBackward")
    this.GraphMenu.add(this.mi.MenuBackward,obm)

    obm:=ObjBindMethod(this,"MenuPause")
    this.GraphMenu.add(this.mi.MenuPause,obm)

    obm:=ObjBindMethod(this,"MenuForward")
    this.GraphMenu.add(this.mi.MenuForward,obm)

    obm:=ObjBindMethod(this,"MenuGoTo")
    this.GraphMenu.add(this.mi.MenuGoTo,obm)

    obm:=ObjBindMethod(this,"MenuMarkers")
    this.GraphMenu.add(this.mi.MenuMarkers,obm)

    obm:=ObjBindMethod(this,"MenuHelp")
    this.GraphMenu.add(this.mi.MenuHelp,obm)

; Создание основного окна
    this.GuiGraph:=Gui("+MinSize400x100 +Resize",this.Name)
    this.GuiGraph.MarginX:=0
    this.GuiGraph.MarginY:=0
    this.GuiGraph.MenuBar:=this.GraphMenu
    this.GuiGraph.Add("Text","w0 h0",Graph.WinText)
    obm:=ObjBindMethod(this,"DropFiles")
    this.GuiGraph.OnEvent("DropFiles",obm)
    obm:=ObjBindMethod(this,"Hide")
    this.GuiGraph.OnEvent("Close",obm)

; Создание окна отрисовки графики
    this.GuiGDIP:=Gui("+owner" this.GuiGraph.Hwnd " -Caption +ToolWindow +E0x08080020") ; WS_EX_LAYERED := 0x80000
    this.GuiGDIP.Show("NoActivate x0 y0 w1 h1")

; Создание окна перехода по времени
    this.GuiGoToT:=Gui("+owner" this.GuiGraph.Hwnd " -sysmenu -Resize","Перейти на время")
    this.GuiGoToT.SetFont("s10")
    this.hTT:=this.GuiGoToT.Add("DateTime","xm+1","HH:mm:ss        dd.MM.yyyy")
    obm:=ObjBindMethod(this,"TTOk")
    this.GuiGoToT.Add("Button","xm+5 y+5","Ok").OnEvent("Click",obm)
    obm:=ObjBindMethod(this,"TTCancel")
    this.GuiGoToT.Add("Button","x+10","Отмена").OnEvent("Click",obm)

; Создание окна перехода к точке
    this.GuiGoToX:=Gui("+owner" this.GuiGraph.Hwnd " -sysmenu -Resize","Перейти к точке")
    this.GuiGoToX.SetFont("s10")
    this.hTX:=this.GuiGoToX.Add("Edit","xm+1 w150 Number",1)
    obm:=ObjBindMethod(this,"TXOk")
    this.GuiGoToX.Add("Button","xm+5 y+5","Ok").OnEvent("Click",obm)
    obm:=ObjBindMethod(this,"TXCancel")
    this.GuiGoToX.Add("Button","x+10","Отмена").OnEvent("Click",obm)

; Создание окна справки
    this.GuiHelp:=Gui("+owner" this.GuiGraph.Hwnd " -sysmenu -Resize","Справка")
    this.GuiHelp.SetFont("s10")
    HelpText:=
    (
      "Левая кнопка мыши - перемещение графика.
      Правая кнопка мыши - выделение и увеличение выделенного участка.
      Клик правой кнопкой - возврат к предыдущему масштабу после увеличения."
    )
    this.GuiHelp.Add("Text",,HelpText)
    obm:=ObjBindMethod(this,"HelpClose")
    this.GuiHelp.Add("Button","xm+10 y+5","Закрыть").OnEvent("Click",obm)

; Создание окна изменения имени выбранного графика
    this.GuiName:=Gui("+owner" this.GuiGraph.Hwnd " -sysmenu -Resize","Имя графика")
    this.GuiName.SetFont("s10")
    this.GuiNameVal:=this.GuiName.Add("Edit","xm+1 w150",3)
    obm:=ObjBindMethod(this,"NameOk")
    this.GuiName.Add("Button","xm+5 y+5","Ok").OnEvent("Click",obm)
    obm:=ObjBindMethod(this,"NameCancel")
    this.GuiName.Add("Button","x+10","Отмена").OnEvent("Click",obm)

; Создание окна изменения значения настройки
    this.GuiVal:=Gui("+owner" this.GuiGraph.Hwnd " -sysmenu -Resize","Изменить")
    this.GuiVal.SetFont("s10")
    this.GuiValText1:=this.GuiVal.Add("Text","xm+10 w350")
    this.GuiValVal:=this.GuiVal.Add("Edit","xm+5 y+5 wp Number",3)
    this.GuiValText2:=this.GuiVal.Add("Text","xm+10 y+1 wp")
    obm:=ObjBindMethod(this,"ValAcc")
    this.GuiVal.Add("Button","xm+5 y+5","Применить").OnEvent("Click",obm)
    obm:=ObjBindMethod(this,"ValOk")
    this.GuiVal.Add("Button","x+10","Ok").OnEvent("Click",obm)
    obm:=ObjBindMethod(this,"ValCancel")
    this.GuiVal.Add("Button","x+10","Отмена").OnEvent("Click",obm)
    this.Whichval:=""

; Запомнить метку для таймера
    this.UpdateTimer:=ObjBindMethod(this,"UpdateGraph")
    this.GuiHiden:=true
;    this.UpdateGraph()

    this.RefCount:=30
    loop this.RefCount
      ObjRelease(ObjPtr(this))

    /*
    форматы обрабатывемых данных

    Data:=[1,2,3,4,5,6,76,56,3,45,6,22,45,234]
    - простой массив значений

    Data:=[[1,A_Now],[2,A_Now],[3,A_Now],[4,A_Now]]
    - массив с меткой времени [[значение,время],[значение,время]...]

    Data:=[[1,A_Now,A_MSec],[2,A_Now,A_MSec],[3,A_Now,A_MSec],[4,A_Now,A_MSec]]
    - массив с меткой времени с миллисекундами [[значение,время,миллисекунды],[значение,время,миллисекунды]...]

    Data:=[[1,2],[[1,A_Now],[2,A_Now]],[[1,A_Now,A_MSec],[2,A_Now,A_MSec]]]
    - массив любых выше перечисленных массивов
    */
  }

  DataArray
  {
    set
    {
      if this.SaveArrName.Length
      {
        this.ArrName:=this.SaveArrName.Clone()
        this.SaveArrName:=[]
      }
      this.Loaded:=2
      this.NewData:=Value
    }
    get
    {
      return this.Data
    }
  }

  Num
  {
    get
    {
      return this.Smooth.Length
    }
  }

  Select
  {
    set
    {
      if !IsInteger(Value)
        return
      if (Value>0 and Value<this.Smooth.Length)
      {
        this.Sel:=Value
      }
    }
    get
    {
      return this.Sel
    }
  }

  AScale
  {
    set
    {
      this.AutoScale[this.Sel]:=Value
    }
    get
    {
      return this.AutoScale[this.Sel]
    }
  }

  ScaleY
  {
    set
    {
      if !IsNumber(Value)
        return
      this.AutoScale[this.Sel]:=false
      this.YScale[this.Sel]:=Value
    }
    get
    {
      return this.YScale[this.Sel]
    }
  }

  ScaleX
  {
    set
    {
      if (!IsNumber(Value) or Value<1)
        return
      if this.ScaleXByTime
        this.ZoomT:=Value
      else
        this.ZoomX:=Value
    }
    get
    {
      if this.ScaleXByTime
        return this.ZoomT
      else
        return this.ZoomX
    }
  }

  Smth
  {
    set
    {
      this.Smooth[this.Sel]:=Value
    }
    get
    {
      return this.Smooth[this.Sel]
    }
  }

  OnTop
  {
    set
    {
      if (Value and !this.AlwaysOnTop)
        this.MenuAlwaysOnTop()
      if (!Value and this.AlwaysOnTop)
        this.MenuAlwaysOnTop()
    }
    get
    {
      return this.AlwaysOnTop
    }
  }

  Transparence
  {
    set
    {
      if !IsInteger(Value)
        return
      this.Transp[this.Sel]:=Value
      this.Pen[this.Sel]:=this.Transp[this.Sel]<<24|this.Pen[this.Sel]&0xffffff
    }
    get
    {
      return this.Transp[this.Sel]
    }
  }

  Colour
  {
    set
    {
      if !IsInteger(Value)
        return
      tmp2:=this.RGBToHSV(Value)
      if ((tmp2>>8)&0xff=0)
      {
        tmp3:=(tmp2&0xff)
        if (tmp3<127)
          tmp3:=127
        this.Hue[this.Sel]:=tmp3<<8
      }
      else
        this.Hue[this.Sel]:=tmp2>>16
      this.Pen[this.Sel]:=0xff000000 | Value
    }
    get
    {
      return this.Pen[this.Sel]
    }
  }

  HitBox(X,Y,Rect)
  {
    return (X>Rect.X and X<Rect.X+Rect.W and Y>Rect.Y and Y<Rect.Y+Rect.H)
  }

;/////////////////////////////////////////////////////////////////////////////////////////////////
;|///////|///////|///////|///////|///////|///////|///////|///////|///////|///////|///////|///////|
;||/////|||/////|||/////|||/////|||/////|||/////|||/////|||/////|||/////|||/////|||/////|||/////||
;|||///|||||///|||||///|||||///|||||///|||||///|||||///|||||///|||||///|||||///|||||///|||||///|||
;||||/|||||||/|||||||/|||||||/|||||||/|||||||/|||||||/|||||||/|||||||/|||||||/|||||||/|||||||/||||
  ReInit()
  {
    this.prevArrSize:=[]
    this.SearchStop:=[]
    this.SearchSkip:=[]
    this.LineW:=[]
    this.Transp:=[]
    this.Smooth:=[]
    this.AutoScale:=[]
    this.SaveAutoScale:=[]
    this.SaveYScale:=[]
    this.GHide:=[]
    this.YScale:=[]
    this.Pen:=[]
    this.Hue:=[]
    this.ArrSize:=[]
    this.prev_ArrSize:=[]
    this.StampT:=[]
    this.LockYP:=[]
    this.LockYM:=[]
    this.Lock_hi_lim:=[]
    this.Lock_lo_lim:=[]
    this.Val_UnderGraph_Drawed:=[]
    this.UnderGX:=[]
    this.UnderGY:=[]
    this.UnderGV:=[]
    this.Sel:=1
    this.ZeroPos:=this.GPosH//3
    this.TimeStampExist:=[]
  }
  GetTime()
  {
    t1:=A_Now
    t2:=A_MSec
    while (t2<5)
    {
      t1:=A_Now
      t2:=A_MSec
    }
    return [t1,t2]
  }
  UpdateGraph()
  {
    ListLines 0
    ObjAddRef(ObjPtr(this))
    if this.GuiHiden
    {
      ObjRelease(ObjPtr(this))
      return
    }
    this.Drawing:=true
    if (this.Loaded and !this.NewData)
    {
      this.MenuForward()
      if (this.Loaded=1)
        this.Pause:=true
      this.Loaded:=0
    }
    if this.NewData
    {
      this.ReInit()
      this.Data:=this.NewData
      this.NewData:=""
    }

    DllCall("QueryPerformanceFrequency", "Int64*",&frequency:=0)
    DllCall("QueryPerformanceCounter","Int64*",&EndTime:=0)
    CycleTime:=round((EndTime-this.StartTime)/frequency*1000,1)
    DllCall("QueryPerformanceCounter", "Int64*",&StartTime:=0)
    this.StartTime:=StartTime

; Взять координаты мыши
    SaveCoordMode:=A_CoordModeMouse
    CoordMode "Mouse","Client"
    MouseGetPos(&mX,&mY,&mW,&mC,2)
    CoordMode "Mouse",SaveCoordMode
    MouseIn:=(this.GuiGraph.hwnd=mW and mY>0)
    DeltaX:=this.OldmX-mX
    DeltaY:=this.OldmY-mY

    this.Pos:=this.DrawString(0,0,0,,,,this.Font_Colour,this.Font_Back)
; очистить поле
    this.FillRectangle(this.WhiteBrush,0,0,this.GPosW,this.GPosH_)

; Добавление координаты маркеру
    if (MouseIn and getkeystate("RButton","P") and mY<this.GPosH and !this.XMarkerOnce)
    {
      this.XMarkerOnce:=true
      this.XMarker[2]:=mX
    }
    else if (this.XMarkerOnce and !getkeystate("RButton","P"))
      this.XMarkerOnce:=false
; Пауза скролинга для режима отображения по времени
    if this.Pause
    {
      this.XTOffset+=CycleTime
      this.OldXTOffset+=CycleTime
    }

; Определение массива массивов
    ArAr:=false
    if (this.Data.Length and isObject(this.Data[1])) ; and this.Data[1].Length)
    {
      if !this.Data[1].Length
      {
        this.MessagePos:=this.DrawString("Нет данных",this.GPosW//2-this.MessagePos.W//2,this.GPosH//2-this.MessagePos.H//2,,,,this.Font_Colour,this.Font_Back)
        if !this.GuiHiden
          this.Update()
        ObjRelease(ObjPtr(this))
        return
      }
      ArAr:=isObject(this.Data[1][1])
      if (!ArAr and this.Data[1].Has(2))
        ArAr:=strlen(this.Data[1][2])!=14
    }
    Ars:=ArAr?this.Data.Length:1

    loop Ars
    {
      this.Proc:=a_index
      if (this.prevArrSize.Length<this.Proc)
      {
        if (this.Proc>10)
          this.ArrName.Push("")
        this.prevArrSize.Push(1)
        this.SearchStop.Push(true)
        this.SearchSkip.Push(0)
        this.LineW.Push(1.0)
        this.Transp.Push(255)
        this.Smooth.Push(true)
        this.AutoScale.Push(true)
        this.SaveAutoScale.Push(false)
        this.GHide.Push(false)
        this.YScale.Push(1)
        this.SaveYScale.Push(1)
        this.Pen.Push("")
        this.Hue.Push(512)
        this.ArrSize.Push(0)
        this.prev_ArrSize.Push(0)
        this.LockYP.Push(0)
        this.LockYM.Push(0)
        this.Val_UnderGraph_Drawed.Push(false)
        this.UnderGX.Push(0)
        this.UnderGY.Push(0)
        this.UnderGV.Push(0)
        this.Lock_hi_lim.Push(false)
        this.Lock_lo_lim.Push(false)
        this.StampT.Push([this.CreateTime])
        this.TimeStampExist.Push(false)

        this.UpdateMenu()
      }

      if (this.Pen[this.Proc]="")
      {
        Hue:=random(0,255)
        if (this.Proc>1 and this.Hue[this.Proc-1])
        {
          loop 100
          {
            Hue:=random(0,255)
            free:=true
            for v in this.Hue
            {
              if (abs(v-Hue)<30)
              {
                free:=false
                break
              }
            }
            if free
              break
          }
        }
        this.Pen[this.Proc]:=this.AHSVToARGB(this.Transp[this.Proc],Hue,255,192)
        this.Hue[this.Proc]:=Hue
      }

      if (this.SearchSkip[this.Proc] and this.Old_XTOffset>this.XTOffset)
      {
        this.SearchStop[this.Proc]:=true
        this.SearchSkip[this.Proc]:=0
      }
    }
    this.Old_XTOffset:=this.XTOffset


    XMarker:=[false,false]
    XMarkeri:=[0,0]
    MarkerTime:=[1601,1601]
    MarkerTimeMs:=[0,0]
    XMarkerCoord:=[0,0]
    MarkerValue:=["",""]
    MarkerText:=["",""]
    MarkerDText:=""
    MarkerMin:=0
    MarkerMax:=0
    StDeviation:=""
    MarkerMean:=""
    StampPos:={X:0,Y:0,W:0,H:this.GPosH+this.MessagePos.H*2,Chars:0,Lines:0}
    prevStampPos:={X:0,Y:0,W:0,H:this.GPosH,Chars:0,Lines:0}
    Stamp:=false
    GetSizeOnce:=false
    prevCoordY:=0
    ValNum:=0
    Deviation:=0

    this.ValTipPos:={X:0,Y:0,W:0,H:0,Chars:0,Lines:0}
    PrevtmpY:=0
    loop________Start:
    loop Ars
    {
      this.Proc:=a_index
      if ArAr
        this.pData:=this.Data[this.Proc]
      else
        this.pData:=this.Data

      ArrSize:=this.pData.Length
      this.ArrSize[this.Proc]:=ArrSize

      this.TimeStampMillis:=false
      if (ArrSize and IsObject(this.pData[ArrSize]))
      {
        if this.pData[ArrSize].Has(2)
          this.TimeStampExist[this.Proc]:=strlen(this.pData[ArrSize][2])=14

        if this.pData[ArrSize].Has(3)
          this.TimeStampMillis:=this.pData[ArrSize][3]!=""
      }
; Добавление временной метки массиву без неё
      if !this.TimeStampExist[this.Proc]
      {
        if (ArrSize>this.prevArrSize[this.Proc] and ArrSize)
        {
          tmp2:=this.StampT[this.Proc][this.prevArrSize[this.Proc]]
          tmp3:=this.TimeSub([A_Now,A_MSec],tmp2)
          tmp1:=ArrSize-this.prevArrSize[this.Proc]
          tmp3:=tmp3//tmp1
          if (tmp3=0)
            tmp3:=1
          loop tmp1
          {
            add:=a_index*tmp3
            this.StampT[this.Proc].Push(this.TimeAddMs(tmp2,add))
          }
          this.prevArrSize[this.Proc]:=ArrSize
        }
      }

      Period:=this.GPosW/this.ZoomX ; количество пикселей на точку по X
      PerioT:=this.GPosW/this.ZoomT ; количество пикселей на миллисекунду по X
      this.PerioT:=PerioT
      if this.YScale[this.Proc]
        Pixel:=this.GPosH/this.YScale[this.Proc] ; сколько пикселей занимает 1 единица по Y
      else
        Pixel:=1
      ZeroPos:=this.ZeroPosU
; Пауза скролинга для режима отображения по точкам
      if (this.Pause and this.Proc=this.Sel and this.prev_ArrSize[this.Proc] and ArrSize!=this.prev_ArrSize[this.Proc])
      {
        tmp1:=ArrSize-this.prev_ArrSize[this.Proc]
        this.X_Offset+=tmp1
        this.OldX_Offset+=tmp1
      }
      this.prev_ArrSize[this.Proc]:=ArrSize

; Перемещение графика
      L_Button:
      if (MouseIn and mY<this.GPosH and getkeystate("LButton","P") and !this.Setting)
      {
        if !this.GetmCoordOnce
        {
          this.LButtonStart:=a_tickcount
          this.Old_mX:=mX
          this.Old_mY:=mY
          this.OldX_Offset:=this.X_Offset
          this.OldXTOffset:=this.XTOffset
          this.GetmCoordOnce:=true
          this.OffsetSetting:=true
          this.ShiftStrt:=true
        }
        this.X_Offset:=this.OldX_Offset-round((this.Old_mX-mX)/Period)
        this.XTOffset:=this.OldXTOffset-round((this.Old_mX-mX)/PerioT)

        DeltaY:=this.Old_mY-mY
        if (this.Sel=this.Proc)
          this.ZeroPos+=DeltaY
        if (this.Sel=this.Proc)
          this.Old_mY:=mY

        if (this.OldX_Offset-this.X_Offset!=0)
          this.MouseMoved:=true
      }
      else if (this.GetmCoordOnce and !getkeystate("LButton","P"))
      {
        this.OffsetSetting:=false
        ; Добавление координаты маркеру
        if !this.MouseMoved
          this.XMarker[1]:=mX
        this.MouseMoved:=false
        this.GetmCoordOnce:=false
      }
      if !getkeystate("LButton","P")
        this.SearchStop[this.Proc]:=false

; Выделение участка
      R_Button:
      if (MouseIn and mY<this.GPosH and getkeystate("RButton","P") and !this.Setting)
      {
        if !this.GetStartPosRectOnce
        {
          this.GetStartPosRectOnce:=true
          this.RectXs:=mX
          this.RectYs:=mY
        }
        if (this.RectXs>mX)
          this.RectX:=mX
        else
          this.RectX:=this.RectXs
        if (this.RectYs>mY)
          this.RectY:=mY
        else
          this.RectY:=this.RectYs
        this.RectW:=abs(this.RectXs-mX)
        this.RectH:=abs(this.RectYs-mY)
        if (this.RectW>10 and this.RectH>10)
          this.DrawRectangle(this.Font_Colour,this.RectX,this.RectY,this.RectW,this.RectH)
        else
          this.DrawRectangle(this.GrayPen2,this.RectX,this.RectY,this.RectW,this.RectH)
      }
      else if (this.GetStartPosRectOnce and !getkeystate("RButton","P"))
      {
        this.GetStartPosRectOnce:=false
        if (this.RectW>10 and this.RectH>10)
        {
          this.RectZoom:=true
          this.SaveZoomX:=this.ZoomX
          this.SaveZoomT:=this.ZoomT
          this.SaveX_Offset:=this.X_Offset
          this.SaveXTOffset:=this.XTOffset
          this.SavePause:=this.Pause
          this.Pause:=true
          this.ShiftStrt:=true
          loop Ars
          {
            this.SaveAutoScale[a_index]:=this.AutoScale[a_index]
            this.SaveZeroPos:=this.ZeroPos
            this.SaveYScale[a_index]:=this.YScale[a_index]
            if this.AutoScale[a_index]
            {
              this.AutoScale[a_index]:=false
            }
            P:=this.GPosH/this.YScale[a_index] ; сколько пикселей занимает 1 единица по Y
            this.YScale[a_index]:=this.RectH/P
          }
          this.UpdateMenu()
          U:=this.SaveYScale[this.Sel]/this.GPosH ; сколько единиц занимает 1 пиксель по Y
          P:=this.GPosH/this.YScale[this.Sel] ; сколько пикселей занимает 1 единица по Y
          RectY2:=(this.RectY+this.RectH)
          this.ZeroPos-=((this.ZeroPosU-RectY2)*U)*P+(this.GPosH-this.ZeroPosU)
          this.ZeroPos:=round(this.ZeroPos)
          if !this.ScaleXByTime
          {
            this.ZoomX:=round(this.RectW/Period)+1
            this.X_Offset+=round((this.GPosW-(this.RectX+this.RectW))/Period)
          }
          else
          {
            this.ZoomT:=round(this.RectW/PerioT)
            this.XTOffset+=round((this.GPosW-(this.RectX+this.RectW))/PerioT)
          }
        }
        else if this.RectZoom
        {
          this.RectZoom:=false
          this.ZoomX:=this.SaveZoomX
          this.ZoomT:=this.SaveZoomT
          this.X_Offset:=this.SaveX_Offset
          this.XTOffset:=this.SaveXTOffset
          this.Pause:=this.SavePause
          this.ShiftStrt:=true
          this.ZeroPos:=this.SaveZeroPos
          loop Ars
          {
            this.YScale[a_index]:=this.SaveYScale[a_index]
            if ((this.SaveAutoScale[a_index] and !this.AutoScale[a_index]) or (!this.SaveAutoScale[a_index] and this.AutoScale[a_index]))
            {
              this.AutoScale[a_index]:=true
              this.UpdateMenu()
            }
          }
        }
      }

; Обработать колесо мыши
      Whell:
      if (MouseIn and (Graph.WheelUp or Graph.WheelDown) and Graph.HotKeymW=this.GuiGraph.Hwnd and this.Proc=1)
      {
        CoefHi:=mY/this.GPosH
        CoefLo:=(this.GPosH-mY)/this.GPosH
        tmp1:=round(this.ZoomX/3)+1
        tmt1:=round(this.ZoomT/3)+1
        if Graph.WheelUp
        {
          this.ZoomX-=tmp1
          this.ZoomT-=tmt1
        }
        else if Graph.WheelDown
        {
          this.ZoomX+=tmp1
          this.ZoomT+=tmt1
        }
        Graph.WheelUp:=false
        Graph.WheelDown:=false
        if (this.ZoomX<10)
          this.ZoomX:=10
        if (this.ZoomX>100000)
          this.ZoomX:=100000
        if (this.ZoomT<1000)
          this.ZoomT:=1000
        if (this.ZoomT>Graph.MaxTime)
          this.ZoomT:=Graph.MaxTime
        this.ShiftStrt:=true
        this.Pause:=true
        tmp1:=(this.GPosW-mX)/Period
        tmp2:=(this.GPosW-mX)/(this.GPosW/this.ZoomX)
        this.X_Offset+=round(tmp1-tmp2)
        tmp1:=(this.GPosW-mX)/PerioT
        tmp2:=(this.GPosW-mX)/(this.GPosW/this.ZoomT)
        this.XTOffset+=round(tmp1-tmp2)
      }

; ограничить перемещение графика
      if (this.Proc=this.Sel)
      {
        if !this.ScaleXByTime
        {
          tmp1:=this.ZoomX//2
          if (this.X_Offset<-tmp1)
            this.X_Offset:=-tmp1
          else if (this.X_Offset>0 and this.X_Offset>this.ArrSize[this.Proc]-tmp1)
            this.X_Offset:=this.ArrSize[this.Proc]-tmp1
        }
        else
        {
          tmp1:=this.ZoomT//2
          if this.TimeStampExist[this.Proc]
          {
            if this.TimeStampMillis
            {
              tmp2:=this.TimeSub([A_Now,A_MSec],[this.pData[this.pData.Length][2],this.pData[this.pData.Length][3]])
              tmp3:=this.TimeSub([A_Now,A_MSec],[this.pData[1][2],this.pData[1][3]])
            }
            else
            {
              tmp2:=this.TimeSub([A_Now,A_MSec],[this.pData[this.pData.Length][2],0])
              tmp3:=this.TimeSub([A_Now,A_MSec],[this.pData[1][2],0])
            }
          }
          else
          {
            tmp2:=this.TimeSub([A_Now,A_MSec],[this.StampT[this.Proc][this.StampT[this.Proc].Length][1],this.StampT[this.Proc][this.StampT[this.Proc].Length][2]])
            tmp3:=this.TimeSub([A_Now,A_MSec],[this.StampT[this.Proc][1][1],this.StampT[this.Proc][1][2]])
          }
          tmp2-=tmp1
          tmp3-=tmp1
          if (this.XTOffset<-tmp1)
          {
            this.XTOffset:=-tmp1
            this.ShiftStrt:=true
          }
          else if (this.XTOffset<tmp2)
          {
            this.XTOffset:=tmp2
            this.ShiftStrt:=true
          }
          else if (this.XTOffset>0 and this.XTOffset>tmp3)
          {
            this.XTOffset:=tmp3
            this.ShiftStrt:=true
          }
;          this.XTOffset:=Integer(this.XTOffset)
        }
      }

; отрисовать сетку
      if (this.Sel=this.Proc)
      {
        tmpc:=this.AHSVToARGB(200,this.Hue[this.Proc],this.Hue[this.Proc]>255?0:100,this.Hue[this.Proc]>255?(this.Hue[this.Proc]>>8):255)
        LineH:=this.Pos.H*2
        RoundTo:=1
        GoAgain:
        Drawed:=0
        if (ZeroPos<=this.GPosH+1 and ZeroPos>=0)
        {
          loop ZeroPos//LineH
          {
            tmp1:=a_index*LineH
            tmp2:=tmp1/Pixel
            Val:=round(tmp2,-(strlen(round(tmp2))-RoundTo))
            if (Val=0)
              continue
            CoordY:=ZeroPos-Val*Pixel
            if (CoordY<0)
              break
            this.DrawString(" " Val,0,CoordY,,,,this.Font_Colour,tmpc)
            this.DrawLine(this.GrayPen2,0,CoordY,this.GPosW,CoordY)
          }
          loop (this.GPosH-ZeroPos)//LineH
          {
            tmp1:=a_index*LineH
            tmp2:=tmp1/Pixel
            Val:=round(tmp2,-(strlen(round(tmp2))-RoundTo))
            if (Val=0)
              continue
            CoordY:=ZeroPos+Val*Pixel
            if (CoordY>this.GPosH)
              break
            this.DrawString("-" Val,0,CoordY-this.Pos.H,,,,this.Font_Colour,tmpc)
            this.DrawLine(this.GrayPen2,0,CoordY,this.GPosW,CoordY)
          }
        }
        else if (ZeroPos>this.GPosH)
        {
          loop this.GPosH//LineH
          {
            tmp1:=ZeroPos-a_index*LineH
            tmp2:=tmp1/Pixel
            Val:=round(tmp2,-(strlen(round(tmp2))-RoundTo))
            CoordY:=ZeroPos-Val*Pixel
            if (prevCoordY!=CoordY and CoordY<=this.GPosH-this.Pos.H and CoordY>=0)
            {
              this.DrawString(" " Val,0,CoordY,,,,this.Font_Colour,tmpc)
              this.DrawLine(this.GrayPen2,0,CoordY,this.GPosW,CoordY)
              Drawed++
            }
            prevCoordY:=CoordY
          }
          if (Drawed<1)
          {
            RoundTo++
            if (RoundTo<10)
              goto GoAgain
            tmp1:=ZeroPos-this.GPosH/2
            tmp2:=tmp1/Pixel
            Val:=round(tmp2)
            CoordY:=ZeroPos-Val*Pixel
            this.DrawString(" " Val,0,CoordY,,,,this.Font_Colour,tmpc)
            this.DrawLine(this.GrayPen2,0,CoordY,this.GPosW,CoordY)
          }
        }
        else if (ZeroPos<0)
        {
          loop this.GPosH//LineH
          {
            tmp1:=-ZeroPos+a_index*LineH
            tmp2:=tmp1/Pixel
            Val:=round(tmp2,-(strlen(round(tmp2))-RoundTo))
            CoordY:=ZeroPos+Val*Pixel
            if (prevCoordY!=CoordY and CoordY<=this.GPosH+1 and CoordY>=this.Pos.H)
            {
              this.DrawString("-" Val,0,CoordY-this.Pos.H,,,,this.Font_Colour,tmpc)
              this.DrawLine(this.GrayPen2,0,CoordY,this.GPosW,CoordY)
              Drawed++
            }
            prevCoordY:=CoordY
          }
          if (Drawed<1)
          {
            RoundTo++
            if (RoundTo<10)
              goto GoAgain
            tmp1:=-ZeroPos+this.GPosH/2
            tmp2:=tmp1/Pixel
            Val:=round(tmp2)
            CoordY:=ZeroPos+Val*Pixel
            this.DrawString("-" Val,0,CoordY-this.Pos.H,,,,this.Font_Colour,tmpc)
            this.DrawLine(this.GrayPen2,0,CoordY,this.GPosW,CoordY)
          }
        }
; отрисовать линию и текст нуля
        if (ZeroPos<=this.GPosH+1 and ZeroPos>=0)
        {
          this.DrawLine(this.GrayPen,0,ZeroPos,this.GPosW,ZeroPos)
          tmp0:=ZeroPos+this.Pos.H//2
          tmp1:=(this.GPosH>tmp0) ? ZeroPos-this.Pos.H//2 : this.GPosH-this.Pos.H
          this.DrawString("0",0,tmp1,,,,this.Font_Colour,tmpc)
        }
      }
; сетка отрисована

      if (!ArrSize and this.Proc=this.Sel)
        this.MessagePos:=this.DrawString("Нет данных",this.GPosW//2-this.MessagePos.W//2,this.GPosH//2-this.MessagePos.H//2,,,,this.Font_Colour,this.Font_Back)
      if (this.SearchSkip[this.Proc]>0)
        this.SearchSkip[this.Proc]--

; Отрисовка графика ----------------------------------------------------------------
      hi_lim:=Graph.min
      lo_lim:=Graph.max
;      Oldi:=1
      NotScaleXByTime:
      this.LockYP[this.Proc]:=0
      this.LockYM[this.Proc]:=0
      StampLine:=this.StampPos.W/2
      this.Val_UnderGraph_Drawed[this.Proc]:=false
      if (!this.ScaleXByTime and ArrSize)
      {
        Old_CoordY:=ZeroPos
        Old_CoordX:=this.GPosW+10
        GPoints:=[[Old_CoordX,Old_CoordY]]
        Aindex:=0
        Oldi:=ArrSize
        if !this.GHide[this.Proc]
        loop this.GPosW
        {
          iLast:=a_index=this.GPosW
          i:=Floor(ArrSize-(a_index/Period+1))-this.X_Offset
          if (i>ArrSize and !iLast)
            continue
          if (i<1)
            i:=1
          if iLast
          {
            if (i-1>0)
              i--
            else
              i:=Oldi
            if (i+1>ArrSize)
              continue
          }
          Aindex++
          if (Aindex=1 and i+1<=ArrSize and i>0)
          {
            if !this.TimeStampExist[this.Proc]
              Value:=this.pData[i]
            else
              Value:=this.pData[i][1]
            tmp1:=Value?Value:0
            Value:=Value!=""?Value:"Null"
            if (tmp1!="")
            {
              hi_lim:=tmp1>hi_lim ? tmp1 : hi_lim
              lo_lim:=tmp1<lo_lim ? tmp1 : lo_lim
            }
            CoordY:=ZeroPos-tmp1*Pixel
            if (CoordY<-1)
              CoordY:=0
            else if (CoordY>this.GPosH+1)
              CoordY:=this.GPosH
            GPoints.Push([this.GPosW,CoordY])
          }
          if !this.TimeStampExist[this.Proc]
            Value:=this.pData[i]
          else
            Value:=this.pData[i][1]
          tmp1:=Value?Value:0
          Value:=Value!=""?Value:"Null"
          if (tmp1!="")
          {
            hi_lim:=tmp1>hi_lim ? tmp1 : hi_lim
            lo_lim:=tmp1<lo_lim ? tmp1 : lo_lim
          }
          CoordX:=this.GPosW-a_index
          CoordY:=ZeroPos-tmp1*Pixel
          SkipLine:=false
          if (CoordY<-1)
          {
            CoordY:=0
            SkipLine:=true
            this.LockYP[this.Proc]++
          }
          else if (CoordY>this.GPosH+1)
          {
            CoordY:=this.GPosH
            SkipLine:=true
            this.LockYM[this.Proc]++
          }
          NewStamp:=false
          NewXMarker:=false
          if (Oldi!=i)
          {
            ; линия графика
            if !this.Smooth[this.Proc]
            {
              GPoints.Push([Old_CoordX,CoordY])
              Old_CoordY:=CoordY
            }
            GPoints.Push([CoordX,CoordY])
            ; Отрисовка подробностей при малом увеличении
            if (Oldi-i>1 and !this.TimeOut)
            {
              max:=Graph.min
              min:=Graph.max
              loop Oldi-i+1
              {
                j:=i+a_index-1
                if (j<1 or j>ArrSize)
                  continue
                if !this.TimeStampExist[this.Proc]
                  tmp1:=this.pData[j]
                else
                  tmp1:=this.pData[j][1]
                min:=min<tmp1?min:tmp1
                max:=max>tmp1?max:tmp1
                if (tmp1!="")
                {
                  hi_lim:=tmp1>hi_lim ? tmp1 : hi_lim
                  lo_lim:=tmp1<lo_lim ? tmp1 : lo_lim
                }
              }
              min:=ZeroPos-min*Pixel
              max:=ZeroPos-max*Pixel
              if (min<0)
                min:=1
              if (min>this.GPosH)
                min:=this.GPosH
              if (max<0)
                max:=0
              if (max>this.GPosH)
                max:=this.GPosH-1
              GPoints.Push([CoordX,min])
              GPoints.Push([CoordX,max])
              GPoints.Push([CoordX,CoordY])
            }
            ; Дорисовать точки при большом увеличении
            if (Old_CoordX-CoordX>3)
              this.DrawEllipse(this.Pen[this.Proc],CoordX-1,CoordY-1,2,2,this.LineW[this.Proc])

            ; текст значения под курсором
            if (!this.Val_UnderGraph_Drawed[this.Proc] and MouseIn)
            if (mX>=CoordX and mX<=CoordX+20)
            if (mY>CoordY and mY<CoordY+20)
            {
              this.Val_UnderGraph_Drawed[this.Proc]:=true
              this.UnderGX[this.Proc]:=CoordX
              this.UnderGY[this.Proc]:=CoordY
              this.UnderGV[this.Proc]:=Value
            }
            Old_CoordX:=CoordX
            Old_CoordY:=CoordY
            Oldi:=i
            NewStamp:=true
            if (this.Sel=this.Proc)
              NewXMarker:=true
          }
          ; линия и текст временой шкалы
          if (this.Sel=this.Proc)
          {
            if Period>=1
              StampLine++
            else
              StampLine+=1
            tmp1:=this.StampPos.W+2
            if (NewStamp and StampLine>tmp1) or (!Stamp and a_index=this.GPosW)
            {
              StampLine:=0
              Stamp:=true
              this.DrawLine(this.GrayPen2,CoordX,0,CoordX,this.GPosH)
              if !this.TimeStampExist[this.Proc]
              {
                tmp10:=FormatTime(this.StampT[this.Proc][i][1],"HH:mm:ss")
                tmp10.="`n" format("{:03}",this.StampT[this.Proc][i][2]) "ms"
              }
              else
              {
                tmp10:=FormatTime(this.pData[i][2],"dd.MM.yyyy'`n'HH:mm:ss")
                if (this.TimeStampMillis and this.pData[i][3]!="")
                  tmp10.="." format("{:03}",this.pData[i][3])
              }
              StampPos:=this.DrawString(tmp10,CoordX-this.StampPos.W/2,this.GPosH,,,,this.Font_Colour,this.GrayPen2)
              if !GetSizeOnce
              {
                GetSizeOnce:=true
                this.StampPos:=StampPos
                this.StampOffset:=this.StampPos.H
              }
              if (prevStampPos.w)
              {
                if (this.StampPos.X+this.StampPos.w>prevStampPos.X)
                  this.StampsNum--
                if (this.StampPos.X+this.StampPos.w*2+5<prevStampPos.X)
                  this.StampsNum++
                if this.StampsNum<2
                  this.StampsNum:=2
              }
              prevStampPos:=this.StampPos
            }
            ; маркеры
            tmp1:=this.GPosW-a_index
            loop 2
            {
              if (NewXMarker and !XMarker[a_index] and tmp1<this.XMarker[a_index])
              {
                XMarker[a_index]:=true
                XMarkeri[a_index]:=i
                XMarkerCoord[a_index]:=tmp1
              }
            }
            NewXMarker:=false
          }
        }
        ; рисовать линию графика
        if !this.GHide[this.Proc]
          this.DrawLines(this.Pen[this.Proc],GPoints,this.LineW[this.Proc])
        ; блокировать перемещение по Y
        this.LockYP[this.Proc]:=(this.LockYP[this.Proc]>=Aindex-3)?1:0
        this.LockYM[this.Proc]:=(this.LockYM[this.Proc]>=Aindex-3)?1:0
      }
      ScaleXByTime:
      if (this.ScaleXByTime and ArrSize)
      {
        Strt:=this.TimeSubMs([A_Now,A_MSec],this.XTOffset)
        if (this.Pause and (!this.SaveStrt[1] or this.OffsetSetting or this.ShiftStrt))
        {
          this.SaveStrt:=Strt
          this.ShiftStrt:=false
        }
        else if (!this.Pause and this.SaveStrt[1])
          this.SaveStrt:=[0,0]
        if this.Pause
          Strt:=this.SaveStrt
        Endt:=this.TimeSubMs(Strt,this.ZoomT)
        ; линия и текст временой шкалы
        if (this.Sel=this.Proc)
        {
          loop this.GPosW
          {
            CoordX:=this.GPosW-(a_index-1)
            StampLine++
            tmp1:=this.StampPos.W+2
            if (StampLine>tmp1) or (!Stamp and a_index=this.GPosW)
            {
              Stamp:=true
              StampLine:=0
              this.DrawLine(this.GrayPen2,CoordX,0,CoordX,this.GPosH)
              tmp2:=(this.ZoomT/this.GPosW)*(a_index-1)
              tmp1:=this.TimeSubMs(Strt,tmp2)
              tmp10:=FormatTime(tmp1[1],"dd.MM.yyyy'`n'HH:mm:ss")
              tmp10.="." tmp1[2]
              StampPos:=this.DrawString(tmp10,CoordX-this.StampPos.W/2,this.GPosH,,,,this.Font_Colour,this.GrayPen2)
              if !GetSizeOnce
              {
                GetSizeOnce:=true
                this.StampPos:=StampPos
                this.StampOffset:=this.StampPos.H
              }
              if (prevStampPos.w)
              {
                if (this.StampPos.X+this.StampPos.w>prevStampPos.X)
                  this.StampsNum--
                if (this.StampPos.X+this.StampPos.w*2+5<prevStampPos.X)
                  this.StampsNum++
                if this.StampsNum<2
                  this.StampsNum:=2
              }
              prevStampPos:=this.StampPos
            }
          }
        }
        ; найти первую точку
        iStart:=1
        Same:=0
        if !this.GHide[this.Proc]
        loop ArrSize
        {
          i:=ArrSize-(a_index-1)-this.SearchSkip[this.Proc]
          if (i<1)
          {
            iStart:=1
            break
          }
          if !this.TimeStampExist[this.Proc]
          {
            iTime:=this.StampT[this.Proc][i][1]
            iTimeMs:=this.StampT[this.Proc][i][2]
            if (iTime>Strt[1] or (iTime=Strt[1] and iTimeMs>=Strt[2]))
              continue
            else
            {
              iStart:=i=ArrSize?i:i+1
              break
            }
          }
          else
          {
            iTime:=this.pData[i][2]
            if this.TimeStampMillis
              iTimeMs:=this.pData[i][3]
            else
            {
              if !Same
              {
                iTimeMs:=0
                loop 1000
                {
                  j:=1+i-a_index
                  if (j>0 and iTime=this.pData[j][2])
                    Same++
                  else
                    break
                }
                SameT:=1000/(Same+1)
              }
              if (Same>0)
              {
                iTimeMs:=round(SameT*Same)
                Same--
              }
            }
            if (iTime>Strt[1] or (this.TimeStampMillis and iTime=Strt[1] and iTimeMs>=Strt[2]))
              continue
            else
            {
              iStart:=i=ArrSize?i:i+1
              break
            }
          }
        }
        Old_CoordY:=ZeroPos
        Old_CoordX:=this.GPosW+10
        GPoints:=[[Old_CoordX,Old_CoordY]]
        SearchSkip:=this.SearchSkip[this.Proc]?this.SearchSkip[this.Proc]:0
        Same:=0
        Aindex:=0
        Oldi:=iStart
        iLast:=false
        if !this.GHide[this.Proc]
        while !iLast ;loop iStart
        {
          i:=iStart-(a_index-1)
          if (i<1)
          {
            i:=1
            iLast:=true
          }
          if !this.TimeStampExist[this.Proc]
          {
            iTime:=this.StampT[this.Proc][i][1]
            iTimeMs:=this.StampT[this.Proc][i][2]
          }
          else
          {
            iTime:=this.pData[i][2]
            if this.TimeStampMillis
              iTimeMs:=this.pData[i][3]
            else
            {
              if !Same
              {
                iTimeMs:=0
                loop 1000
                {
                  j:=i-a_index
                  if (j>0 and iTime=this.pData[j][2])
                    Same++
                  else
                    break
                }
                SameT:=1000/(Same+1)
              }
              if (Same>0)
              {
                iTimeMs:=round(SameT*Same)
                Same--
              }
            }
          }
          if (iTime<Endt[1])
            iLast:=true
          mms:=Strt[2]-iTimeMs
          if (mms<0)
          {
            mms+=1000
            iTime:=DateAdd(iTime,1,"Seconds")
          }
          ttt:=DateDiff(Strt[1],iTime,"Seconds")
          CoordX:=this.GPosW-round(PerioT*(ttt*1000+mms))
          Aindex++
          if (Aindex=1 and !this.SearchStop[this.Proc])
          {
            tmp1:=ArrSize-i
            if (SearchSkip<tmp1)
              SearchSkip:=tmp1
          }
          if (CoordX!=Old_CoordX or iLast)
          {
            if !this.TimeStampExist[this.Proc]
              Value:=this.pData[i]
            else
              Value:=this.pData[i][1]
            tmp1:=Value?Value:0
            if (Value!="" and Aindex)
            {
              hi_lim:=Value>hi_lim ? Value : hi_lim
              lo_lim:=Value<lo_lim ? Value : lo_lim
            }
            Value:=Value!=""?Value:"Null"
            CoordY:=ZeroPos-tmp1*Pixel
            SkipLine:=false
            if (CoordY<-1)
            {
              CoordY:=0
              SkipLine:=true
              this.LockYP[this.Proc]++
            }
            else if (CoordY>this.GPosH+1)
            {
              CoordY:=this.GPosH
              SkipLine:=true
              this.LockYM[this.Proc]++
            }
            ; линия графика
            if !this.Smooth[this.Proc]
            {
              GPoints.Push([Old_CoordX,CoordY])
              Old_CoordY:=CoordY
            }
            GPoints.Push([CoordX,CoordY])
            ; Отрисовка подробностей при малом увеличении
            if (Oldi-i>1 and !this.TimeOut)
            {
              max:=Graph.min
              min:=Graph.max
              loop Oldi-i
              {
                j:=i+a_index-1
                if (j<1 or j>ArrSize)
                  continue
                if !this.TimeStampExist[this.Proc]
                  tmp1:=this.pData[j]
                else
                  tmp1:=this.pData[j][1]
                min:=min<tmp1?min:tmp1
                max:=max>tmp1?max:tmp1
                if (tmp1!="")
                {
                  hi_lim:=tmp1>hi_lim ? tmp1 : hi_lim
                  lo_lim:=tmp1<lo_lim ? tmp1 : lo_lim
                }
              }
              min:=ZeroPos-min*Pixel
              max:=ZeroPos-max*Pixel
              if (min<0)
                min:=1
              if (min>this.GPosH)
                min:=this.GPosH
              if (max<0)
                max:=0
              if (max>this.GPosH)
                max:=this.GPosH-1
              GPoints.Push([CoordX,min])
              GPoints.Push([CoordX,max])
              GPoints.Push([CoordX,CoordY])
            }
            ; Дорисовать точки при большом увеличении
            if (Old_CoordX-CoordX>3)
              this.DrawEllipse(this.Pen[this.Proc],CoordX-1,CoordY-1,2,2,this.LineW[this.Proc])

            ; текст значения под курсором
            if (!this.Val_UnderGraph_Drawed[this.Proc] and MouseIn)
            if (mX>=CoordX and mX<=CoordX+20)
            if (mY>CoordY and mY<CoordY+20)
            {
              this.Val_UnderGraph_Drawed[this.Proc]:=true
              this.UnderGX[this.Proc]:=CoordX
              this.UnderGY[this.Proc]:=CoordY
              this.UnderGV[this.Proc]:=Value
            }
            Old_CoordX:=CoordX
            Old_CoordY:=CoordY
            Oldi:=i
            if iLast
              break
            ; маркеры
            if (this.Sel=this.Proc)
            {
              loop 2
              {
                if (!XMarker[a_index] and CoordX<this.XMarker[a_index])
                {
                  XMarker[a_index]:=true
                  XMarkeri[a_index]:=i
                  if !this.TimeStampMillis
                    MarkerTimeMs[a_index]:=format("{:03}",iTimeMs)
                  XMarkerCoord[a_index]:=CoordX
                }
              }
            }
          }
        }
        ; рисовать линию графика
        if !this.GHide[this.Proc]
          this.DrawLines(this.Pen[this.Proc],GPoints,this.LineW[this.Proc])
        this.ZoomX:=Aindex?Aindex:1
        this.SearchSkip[this.Proc]:=SearchSkip

        ; блокировать перемещение по Y
        this.LockYP[this.Proc]:=(this.LockYP[this.Proc]>=Aindex-3)?1:0
        this.LockYM[this.Proc]:=(this.LockYM[this.Proc]>=Aindex-3)?1:0
      }
      ; Автомасштаб
      if (this.AutoScale[this.Proc] and !this.GHide[this.Proc] and (!this.OScale or this.Proc=this.Sel))
      {
        tmp1:=this.GPosH//2
        if (this.ZeroPosU>tmp1 and this.ZeroPosU<this.GPosH+1)
        {
          if (hi_lim>0)
            this.YScale[this.Proc]:=abs(hi_lim)+(this.GPosH-this.ZeroPosU+10)/Pixel
          else
            this.YScale[this.Proc]:=-lo_lim+(this.ZeroPosU+10)/Pixel
        }
        else if (this.ZeroPosU<=tmp1 and this.ZeroPosU>0)
        {
          if (lo_lim<0)
            this.YScale[this.Proc]:=-lo_lim+(this.ZeroPosU+10)/Pixel
          else
            this.YScale[this.Proc]:=abs(hi_lim)+(this.GPosH-this.ZeroPosU+10)/Pixel
        }
        if (this.YScale[this.Proc]=0)
          this.YScale[this.Proc]:=1
      }
      this.DrawLine(this.GrayPen2,0,this.GPosH,this.GPosW,this.GPosH)
      this.DrawLine(this.GrayPen2,0,this.GPosH+StampPos.H,this.GPosW,this.GPosH+StampPos.H)

      ; текст значения под курсором
      if this.Val_UnderGraph_Drawed[this.Proc]
      {
        this.DrawEllipse(0xffffffff,this.UnderGX[this.Proc]-3,this.UnderGY[this.Proc]-3,6,6,this.LineW[this.Proc])
        this.DrawEllipse(0xff000000,this.UnderGX[this.Proc]-2,this.UnderGY[this.Proc]-2,4,4,this.LineW[this.Proc])
        this.DrawEllipse(0xffffffff,this.UnderGX[this.Proc]-1,this.UnderGY[this.Proc]-1,2,2,this.LineW[this.Proc])
        tmpX:=this.UnderGX[this.Proc]+(5<this.GPosW-this.ValTipPos.W)?this.UnderGX[this.Proc]+5:this.GPosW-this.ValTipPos.W
        tmpY:=(this.UnderGY[this.Proc]-this.Pos.H<0)?0:(this.UnderGY[this.Proc]-this.Pos.H-5)
        if (tmpY-PrevtmpY<this.ValTipPos.H)
        {
          if (mY>this.GPosH//2)
            tmpY:=PrevtmpY-this.ValTipPos.H
          else
          {
            tmpY:=PrevtmpY+this.ValTipPos.H
            tmpX+=8
          }
        }
        tmpC:=this.AHSVToARGB(200,this.Hue[this.Proc],this.Hue[this.Proc]>255?0:100,this.Hue[this.Proc]>255?(this.Hue[this.Proc]>>8):255)
        this.ValTipPos:=this.DrawString((IsInteger(this.UnderGV[this.Proc])?this.UnderGV[this.Proc]:Format("{:0." this.FloatFormat "f}",this.UnderGV[this.Proc])) " " this.ArrName[this.Proc],tmpX,tmpY,,,,this.Font_Colour,tmpC)
        PrevtmpY:=tmpY
      }
      if (this.ShowMarkers and this.Sel=this.Proc)
      {
        if (XMarkerCoord[1] or XMarkerCoord[2])
        {
          MarkerText[1]:=(this.ArrName[this.Proc]!=""?this.ArrName[this.Proc]:"Линия №" this.Proc) " Точек = " abs(XMarkeri[1]-XMarkeri[2])+1 "`nВремя        "
          if this.TimeStampExist[this.Proc]
            loop 11
              MarkerText[1].=" "
          MarkerText[1].="Значение`n"
        }
        loop 2
        {
          if XMarkerCoord[a_index]
          {
            if !this.TimeStampExist[this.Proc]
            {
              MarkerTime[a_index]:=this.StampT[this.Proc][XMarkeri[a_index]][1]
              MarkerTimeMs[a_index]:=this.StampT[this.Proc][XMarkeri[a_index]][2]
              tmp10:=FormatTime(MarkerTime[a_index],"HH:mm:ss") "." MarkerTimeMs[a_index]
              MarkerValue[a_index]:=this.pData[XMarkeri[a_index]]
              MarkerText[a_index].=tmp10 " " Format("{:0." this.FloatFormat "f}",MarkerValue[a_index])
            }
            else
            {
              MarkerTime[a_index]:=this.pData[XMarkeri[a_index]][2]
              if (this.TimeStampMillis and this.pData[XMarkeri[a_index]][3]!="")
                MarkerTimeMs[a_index]:=this.pData[XMarkeri[a_index]][3]
              tmp10:=FormatTime(MarkerTime[a_index],"dd.MM.yyyy HH:mm:ss") "." MarkerTimeMs[a_index]
              MarkerValue[a_index]:=this.pData[XMarkeri[a_index]][1]
              MarkerText[a_index].=tmp10 " " Format("{:0." this.FloatFormat "f}",this.pData[XMarkeri[a_index]][1])
            }
          }
        }
        if (XMarkerCoord[1] and XMarkerCoord[2])
        {
          i:=1, j:=2
          if (XMarkerCoord[1]<XMarkerCoord[2])
            i:=2, j:=1
          ms:=MarkerTimeMs[i]-MarkerTimeMs[j]
          if (ms<0)
            MarkerTime[j]:=DateAdd(MarkerTime[j],1,"Seconds")
          MarkerDeltaT:=DateDiff(MarkerTime[i],MarkerTime[j],"Seconds")
          MarkerDeltaT:=DateAdd(1601,MarkerDeltaT,"Seconds")
          Y:=FormatTime(MarkerDeltaT,"yyyy")
          M:=FormatTime(MarkerDeltaT,"MM")
          D:=FormatTime(MarkerDeltaT,"dd")
          Y:=format("{:04}",Y-1601)
          M:=format("{:02}",M-1)
          D:=format("{:02}",D-1)
          if this.TimeStampExist[this.Proc]
            MarkerDText.=D "." M "." Y " "
          tmp10:=FormatTime(MarkerDeltaT,"HH:mm:ss")
          MarkerDText.=tmp10
          if MarkerTimeMs[i]
            MarkerDText.="." format("{:03}",abs(ms))

          MarkerMax:=Graph.min
          MarkerMin:=Graph.max
          ValNum:=XMarkeri[i]-XMarkeri[j]+1
          Summ:=0
          loop ValNum
          {
            if !this.TimeStampExist[this.Proc]
              Val:=this.pData[XMarkeri[j]+A_Index-1]
            else
              Val:=this.pData[XMarkeri[j]+A_Index-1][1]
            Summ+=Val
            if (Val>MarkerMax)
              MarkerMax:=Val
            if (Val<MarkerMin)
              MarkerMin:=Val
          }
          MarkerMean:=Summ/ValNum
          loop ValNum
          {
            if !this.TimeStampExist[this.Proc]
              Val:=this.pData[XMarkeri[j]+A_Index-1]
            else
              Val:=this.pData[XMarkeri[j]+A_Index-1][1]
            Deviation+=(Val-MarkerMean)**2
          }
        }
      }
    } ; Конец цикла
    Loop________End:

; общий масштаб
    if this.OScale
    {
      loop this.YScale.Length
      {
        if (a_index=this.Sel)
          continue
        this.YScale[a_index]:=this.YScale[this.Sel]
      }
    }

; Отрисовать меню
    OnGraphMenu:
    SelPos:=[]
    tmpc:=this.AHSVToARGB(200,this.Hue[1],this.Hue[1]>255?0:100,this.Hue[1]>255?(this.Hue[1]>>8):255)
    ; первая строка (этой строки может не быть)
    MenuSPY:=StampPos.Y+StampPos.H
    if (Ars>1)
      Pos:=this.DrawString("1",0,MenuSPY,,,"Center vCenter",this.GHide[1]?tmpc:this.Font_Colour,tmpc)
    else
      Pos:={X:0,Y:0,W:0,H:0,Chars:0,Lines:0}
    SelPos.Push(Pos)
    loop Ars
    {
      tmp1:=a_index+1
      if (tmp1<=Ars)
      {
        tmpc:=this.AHSVToARGB(200,this.Hue[tmp1],this.Hue[tmp1]>255?0:100,this.Hue[tmp1]>255?(this.Hue[tmp1]>>8):255)
        Pos:=this.DrawString(tmp1,SelPos[a_index].X+SelPos[a_index].W+5,MenuSPY,,,"Center vCenter",this.GHide[tmp1]?tmpc:this.Font_Colour,tmpc)
      }
      else
        Pos:=this.DrawString("Выбран " this.Sel (this.ArrName[this.Sel]?"-`"" this.ArrName[this.Sel] "`"":""),SelPos[a_index].X+SelPos[a_index].W+5,MenuSPY,,,"Center vCenter",this.Font_Colour,this.LightBlueBrush)
      SelPos.Push(Pos)
    }
    ; вторая строка (первая)
    MenuSPY:=StampPos.Y+StampPos.H+SelPos[1].H
    if !this.ScaleXByTime
      this.ZoomPos:=this.DrawString("Zoom X = " this.ZoomX " точек",0,MenuSPY,,,"",this.Font_Colour,this.LightBlueBrush)
    else
    {
      tmp1:=this.MsToTime(this.ZoomT)
      tmp1[1]-=1000000
      tmp2:=FormatTime(tmp1[1],"dd HH:mm:ss")
      tmp2.="." tmp1[2]
      this.ZoomPos:=this.DrawString("Zoom X = " tmp2,0,MenuSPY,,,"",this.Font_Colour,this.LightBlueBrush)
    }
    this.SmoothPos:=this.DrawString(this.Smooth[this.Sel]?"~~~~":"_-_-",this.ZoomPos.W+this.Pos.W,MenuSPY,,,"",this.Font_Colour,this.LightBlueBrush)
    this.TransPos:=this.DrawString("<" this.Transp[this.Sel] ">",this.SmoothPos.X+this.SmoothPos.W+this.Pos.W,MenuSPY,,,"",this.Font_Colour,this.LightBlueBrush)
    this.LineWPos:=this.DrawString("[" this.LineW[this.Sel] "]",this.TransPos.X+this.TransPos.W+this.Pos.W,MenuSPY,,,"",this.Font_Colour,this.LightBlueBrush)
    this.FontSizePos:=this.DrawString("Шрифт " this.FontSize,this.LineWPos.X+this.LineWPos.W+this.Pos.W,MenuSPY,,,"",this.Font_Colour,this.LightBlueBrush)
    ; третья строка (вторая)
    MenuSPY+=this.ZoomPos.H
    this.AutoPos:=this.DrawString("Авто",0,MenuSPY,,,"",this.AutoScale[this.Sel]?this.Font_Colour:this.GrayPen,this.LightBlueBrush)
    this.ScalePos:=this.DrawString("Шкала " Format("{:0." this.FloatFormat "f}",this.YScale[this.Sel]),this.AutoPos.X+this.AutoPos.W,MenuSPY,,,"",this.Font_Colour,this.LightBlueBrush)
    if ArAr
      this.OScalePos:=this.DrawString(" общая",this.ScalePos.X+this.ScalePos.W,MenuSPY,,,"",this.OScale?this.Font_Colour:this.GrayPen,this.LightBlueBrush)
    BWPos:=this.DrawString("(<<)",this.ScalePos.X+this.ScalePos.W+this.OScalePos.W+15,MenuSPY,,,"Center vCenter",this.Font_Colour,this.LightBlueBrush)
    PWPos:=this.DrawString("(||)",BWPos.X+BWPos.W+2,MenuSPY,,,"Center vCenter",this.Font_Colour,this.LightBlueBrush)
    FWPos:=this.DrawString("(>>)",PWPos.X+PWPos.W+2,MenuSPY,,,"Center vCenter",this.Font_Colour,this.LightBlueBrush)

    ; Размер меню
    tmp1:=(this.AutoPos.H>this.ScalePos.H)?this.AutoPos.H:this.ScalePos.H
    this.MenuOffset:=this.ZoomPos.H+tmp1+SelPos[1].H

    ; хитбоксы
    SelHBA:=[]
    SelHB:=0
    SelSplitHB:=false
    loop Ars
    {
      SelHBA.Push(this.HitBox(mX,mY,SelPos[a_index]))
      if SelHBA[a_index]
      {
        SelHB:=a_index
        break
      }
    }
    if ArAr
      SelSplitHB:=this.HitBox(mX,mY,SelPos[Ars+1])
    LineWHB:=this.HitBox(mX,mY,this.LineWPos)
    TransHB:=this.HitBox(mX,mY,this.TransPos)
    FontSizeHB:=this.HitBox(mX,mY,this.FontSizePos)
    ZoomHB:=this.HitBox(mX,mY,this.ZoomPos)
    SmoothHB:=this.HitBox(mX,mY,this.SmoothPos)
    AutoHB:=this.HitBox(mX,mY,this.AutoPos)
    ScaleHB:=this.HitBox(mX,mY,this.ScalePos)
    OScaleHB:=this.HitBox(mX,mY,this.OScalePos)
    BWHB:=this.HitBox(mX,mY,BWPos)
    PWHB:=this.HitBox(mX,mY,PWPos)
    FWHB:=this.HitBox(mX,mY,FWPos)
    HB:=AutoHB or ScaleHB or ZoomHB or SmoothHB or LineWHB or TransHB or FontSizeHB
   or SelHB or OScaleHB or SelSplitHB or BWHB or PWHB or FWHB
    if (MouseIn and HB and !this.OffsetSetting and !this.Setting and A_Cursor="Arrow")
    {
      this.Setting:=true
      if AutoHB
      {
        TipText:="Автоматический масштаб  вкл./выкл."
        this.WhichSetting:=1
      }
      else if ScaleHB
      {
        TipText:="Масштаб шкалы`nЗажмите левую кн. мыши`n и потяните вверх/вниз`n или правой кнопкой мыши"
        this.WhichSetting:=2
      }
      else if ZoomHB
      {
        TipText:="Масштаб по горизонтали`nЗажмите левую кн. мыши`n и потяните вверх/вниз`n или правой кнопкой мыши"
        this.WhichSetting:=3
      }
      else if LineWHB
      {
        TipText:="Толщина линии графика`nЗажмите левую кн. мыши`n и потяните вверх/вниз`n или правой кнопкой мыши"
        this.WhichSetting:=4
      }
      else if SelHB
      {
        TipText:="Нажмите левой кн. мыши чтобы`n выбрать график, настройки`n которого будут изменяться`nПравой кн. мыши - выключить график`n`n" this.ArrName[SelHB]
        this.WhichSetting:=5
      }
      else if FontSizeHB
      {
        TipText:="Размер шрифта`nЗажмите левую кн. мыши`n и потяните вверх/вниз`n или правой кнопкой мыши"
        this.WhichSetting:=6
      }
      else if SmoothHB
      {
        TipText:="Сглаживать ступеньки графика  вкл./выкл."
        this.WhichSetting:=7
      }
      else if OScaleHB
      {
        TipText:="Общий масштаб шкалы  вкл./выкл."
        this.WhichSetting:=8
      }
      else if SelSplitHB
      {
        TipText:="Нажмите чтобы отделить `nвыбранный график в отдельное окно`n`n" this.ArrName[this.Sel]
        this.WhichSetting:=9
      }
      else if BWHB
      {
        TipText:="На 1 экран назад"
        this.WhichSetting:=10
      }
      else if PWHB
      {
        TipText:="Пауза прокрутки"
        this.WhichSetting:=11
      }
      else if FWHB
      {
        TipText:="На 1 экран вперед"
        this.WhichSetting:=12
      }
      else if TransHB
      {
        TipText:="Видимость линии графика`nЗажмите левую кн. мыши`n и потяните вверх/вниз`n или правой кнопкой мыши"
        this.WhichSetting:=13
      }
      this.TipPos:=this.DrawString(TipText,(this.GPosW-this.TipPos.W)//2,this.GPosH-this.TipPos.H,,,,this.Font_Colour,this.LightGreenBrush)
    }
    ; Изменение настроек
    if (getkeystate("LButton","P") and this.Setting)
    {
      if (this.WhichSetting=1)
      {
        this.AutoScale[this.Sel]:=!this.AutoScale[this.Sel]
        if this.OScale
          loop Ars
            this.AutoScale[a_index]:=this.AutoScale[this.Sel]
        this.WhichSetting:=0
      }
      else if (this.WhichSetting=2)
      {
        this.YScale[this.Sel]+=(round(abs(this.YScale[this.Sel])/20)+1)*DeltaY
        this.YScale[this.Sel]:=round(this.YScale[this.Sel])
        this.AutoScale[this.Sel]:=false
      }
      else if (this.WhichSetting=3)
      {
        this.ZoomX+=(round(abs(this.ZoomX)/20)+1)*DeltaY
        this.ZoomX:=(this.ZoomX>100000)?100000:(this.ZoomX<10)?10:round(this.ZoomX)
        this.ZoomT+=(round(abs(this.ZoomT)/20)+1)*DeltaY
        this.ZoomT:=(this.ZoomT>Graph.MaxTime)?Graph.MaxTime:(this.ZoomT<1000)?1000:round(this.ZoomT)
      }
      else if (this.WhichSetting=4)
      {
        this.LineW[this.Sel]+=DeltaY/10
        if (this.LineW[this.Sel]<1)
          this.LineW[this.Sel]:=1
        if (this.LineW[this.Sel]>5)
          this.LineW[this.Sel]:=5
        this.LineW[this.Sel]:=round(this.LineW[this.Sel],1)
      }
      else if (this.WhichSetting=5)
      {
        loop Ars
        {
          if (SelHBA[a_index])
          {
            this.Sel:=a_index
            this.UpdateMenu()
            break
          }
        }
        this.WhichSetting:=0
      }
      else if (this.WhichSetting=6)
      {
        this.FontSize+=DeltaY
        if (this.FontSize<8)
          this.FontSize:=8
        if (this.FontSize>70)
          this.FontSize:=70
        if (this.FontSize!=this.prevSize)
          this.SetFont(,this.FontSize)
      }
      else if (this.WhichSetting=7)
      {
        this.Smooth[this.Sel]:=!this.Smooth[this.Sel]
        this.WhichSetting:=0
      }
      else if (this.WhichSetting=8)
      {
        this.OScale:=!this.OScale
        this.WhichSetting:=0
      }
      else if (this.WhichSetting=9)
      {
        this.GuiGraph.GetPos(&x,&y)
        this.Child.Push(Graph("График `"" this.ArrName[this.Sel] "`""))
        this.Child[this.Child.Length].CreateTime:=this.CreateTime
        this.Child[this.Child.Length].Show(x+20,y+20)
        this.Parent++
        this.Child[this.Child.Length].IsChild:=this.Parent
        this.Child[this.Child.Length].DataArray:=this.Data[this.Sel]
        this.Child[this.Child.Length].ArrName[1]:=this.ArrName[this.Sel]
;        this.Child[this.Child.Length].         :=this.ArrName[this.Sel]
        this.Child[this.Child.Length].Parent:=this
        ObjRelease(ObjPtr(this))
        this.WhichSetting:=0
        this.GHide[this.Sel]:=true
        loop Ars
        {
          if !this.GHide[a_index]
            this.Sel:=a_index
        }
      }
      else if (this.WhichSetting=10)
      {
        if !this.ScaleXByTime
          this.X_Offset+=this.ZoomX
        else
          this.XTOffset+=this.ZoomT
        this.ShiftStrt:=true
        this.WhichSetting:=0
      }
      else if (this.WhichSetting=11)
      {
        this.Pause:=!this.Pause
        this.WhichSetting:=0
      }
      else if (this.WhichSetting=12)
      {
        if !this.ScaleXByTime
          this.X_Offset-=this.ZoomX
        else
          this.XTOffset-=this.ZoomT
        this.ShiftStrt:=true
        this.WhichSetting:=0
      }
      else if (this.WhichSetting=13)
      {
        this.Transp[this.Sel]+=DeltaY
        if (this.Transp[this.Sel]<1)
          this.Transp[this.Sel]:=1
        if (this.Transp[this.Sel]>255)
          this.Transp[this.Sel]:=255
        this.Pen[this.Sel]:=this.Transp[this.Sel]<<24|this.Pen[this.Sel]&0xffffff
      }
    }
    if (getkeystate("RButton","P") and this.Setting)
    {
      if (this.WhichSetting=5)
      {
        loop Ars
        {
          if (SelHBA[a_index])
          {
            this.GHide[a_index]:=!this.GHide[a_index]
            if this.GHide[a_index]
            {
              loop Ars
              {
                if !this.GHide[a_index]
                  this.Sel:=a_index
              }
            }
            break
          }
        }
        this.WhichSetting:=0
      }
      else if (this.WhichSetting=2)
      {
        this.WhichVal:="YScale"
        this.GuiValText1.Value:="Масштаб шкалы"
        this.GuiValVal.Value:=this.YScale[this.Sel]
        this.GuiValText2.Value:=""
        this.MenuVal()
        this.WhichSetting:=0
      }
      else if (this.WhichSetting=3)
      {
        this.GuiValText1.Value:="Масштаб по горизонтали"
        if this.ScaleXByTime
        {
          this.WhichVal:="ZoomT"
          this.GuiValVal.Value:=this.ZoomT/60000
          this.GuiValText2.Value:="минут"
        }
        else
        {
          this.WhichVal:="ZoomX"
          this.GuiValVal.Value:=this.ZoomX
          this.GuiValText2.Value:="точек"
        }
        this.MenuVal()
        this.WhichSetting:=0
      }
      else if (this.WhichSetting=4)
      {
        this.WhichVal:="LineW"
        this.GuiValText1.Value:="Толщина линии графика"
        this.GuiValVal.Value:=this.LineW[this.Sel]
        this.GuiValText2.Value:=""
        this.MenuVal()
        this.WhichSetting:=0
      }
      else if (this.WhichSetting=6)
      {
        this.WhichVal:="FontSize"
        this.GuiValText1.Value:="Размер шрифта"
        this.GuiValVal.Value:=this.FontSize
        this.GuiValText2.Value:=""
        this.MenuVal()
        this.WhichSetting:=0
      }
      else if (this.WhichSetting=13)
      {
        this.WhichVal:="Transp"
        this.GuiValText1.Value:="Видимость линии графика"
        this.GuiValVal.Value:=this.Transp[this.Sel]
        this.GuiValText2.Value:="0=прозрачен 255=видим"
        this.MenuVal()
        this.WhichSetting:=0
      }
    }
    if (!getkeystate("LButton","P") and !getkeystate("RButton","P"))
    {
      this.Setting:=false
      this.WhichSetting:=0
    }

; Информация от маркеров
    Markers:
    max:=min:="`n"
    if this.ShowMarkers
    {
      loop 2
      {
        if XMarkerCoord[a_index]
          this.DrawLine(this.RedPen,XMarkerCoord[a_index],0,XMarkerCoord[a_index],this.GPosH)
      }
      if !XMarkerCoord[1]
        MarkerText[1]:="Нажмите левой кн. мыши на график"
      if !XMarkerCoord[2]
        MarkerText[2]:="Нажмите правой кн. мыши на график"
      if (XMarkerCoord[1] and XMarkerCoord[2])
      {
        StDeviation:=sqrt((Deviation/ValNum))
        StDeviation:="Среднекв. отклонение = " Format("{:0." this.FloatFormat "f}",StDeviation)
        MarkerMean:="Среднее = " Format("{:0." this.FloatFormat "f}",MarkerMean)
        min:="Min = " Format("{:0." this.FloatFormat "f}",MarkerMin)
        max:="Max = " Format("{:0." this.FloatFormat "f}",MarkerMax)
      }
      String:=MarkerText[1] "`n" MarkerText[2] "`n" MarkerDText "`n" MarkerMean "`n" StDeviation "`n" max "`n" min
      Pos:=this.DrawString(String,0,this.AutoPos.Y+this.AutoPos.H,this.GPosW,,"",this.Font_Colour,this.LightGreenBrush)
    }

; Подсказка о текущем увеличении
    if ((!this.ScaleXByTime and this.OldZoomX!=this.ZoomX) or this.OldZoomT!=this.ZoomT)
    {
      this.ShowZoomTip:=1000
      this.OldZoomX:=this.ZoomX
      this.OldZoomT:=this.ZoomT
    }
    if (this.ShowZoomTip>0)
    {
      this.ShowZoomTip-=CycleTime
      if !this.ScaleXByTime
        this.iZoomPos:=this.DrawString("Zoom`n" this.ZoomX "`nточек",(this.GPosW-this.iZoomPos.W)//2,0,,,,this.Font_Colour,this.LightGreenBrush)
      else
      {
        tmp1:=this.MsToTime(this.ZoomT)
        tmp1[1]+=-1000000
        tmp2:=FormatTime(tmp1[1],"dd HH:mm:ss")
        tmp2.="." tmp1[2]
        this.iZoomPos:=this.DrawString("Zoom`n" tmp2,(this.GPosW-this.iZoomPos.W)//2,0,,,,this.Font_Colour,this.LightGreenBrush)
      }
    }
; Подсказка о времени отрисовки
    DllCall("QueryPerformanceCounter","Int64*",&EndTime:=0)
    ElapsedTime:=round((EndTime-StartTime)/frequency*1000,1)
    this.ETPos:=this.DrawString(ElapsedTime "ms",this.GPosW-this.ETPos.W,this.ZoomPos.Y+this.ETPos.H,,,,this.Font_Colour,this.Font_Back)
    if (this.HitBox(mX,mY,this.ETPos) and MouseIn)
      this.TipPos:=this.DrawString("Время отрисовки кадра",(this.GPosW-this.TipPos.W)//2,this.GPosH-this.TipPos.H,,,,this.Font_Colour,this.LightGreenBrush)

    if !this.ScaleXByTime
    {
      if (ElapsedTime>1000)
      {
        if !this.TimeOut
        {
          this.TOZoomX:=this.ZoomX
          this.TimeOut:=true
        }
        else
          this.ZoomX-=round(abs(this.ZoomX)/10)
      }
      else if (this.TimeOut and this.ZoomX<this.TOZoomX or ElapsedTime<100)
      {
        this.TimeOut:=false
      }
    }
    else
    {
      if (ElapsedTime>1000)
      {
        if !this.TimeOut
        {
          this.TOZoomT:=this.ZoomT
          this.TimeOut:=true
        }
        else
          this.ZoomT-=round(abs(this.ZoomT)/10)
      }
      else if (this.TimeOut and this.ZoomT<this.TOZoomT or ElapsedTime<100)
      {
        this.TimeOut:=false
      }
    }

; Обновить изображение
    if !this.GuiHiden
      this.Update()

    this.OldmX:=mX
    this.OldmY:=mY
    this.Drawing:=false
    ObjRelease(ObjPtr(this))
  }
;||||/|||||||/|||||||/|||||||/|||||||/|||||||/|||||||/|||||||/|||||||/|||||||/|||||||/|||||||/||||
;|||///|||||///|||||///|||||///|||||///|||||///|||||///|||||///|||||///|||||///|||||///|||||///|||
;||/////|||/////|||/////|||/////|||/////|||/////|||/////|||/////|||/////|||/////|||/////|||/////||
;|///////|///////|///////|///////|///////|///////|///////|///////|///////|///////|///////|///////|
;/////////////////////////////////////////////////////////////////////////////////////////////////

  TimeSub(Time1,Time2)
  {
    T1:=Time1[1]
    T2:=Time2[1]
    ms:=Time1[2]-Time2[2]
    if (ms<0)
    {
      ms+=1000
      T2:=DateAdd(T2,1,"Seconds")
    }
    Dif:=DateDiff(T1,T2,"Seconds")
    return Dif*1000+ms
  }
  TimeSubMs(Time,ValueMs)
  {
    ValueMs:=round(ValueMs)
    if (ValueMs=0)
      return Time
    m:=0
    if (ValueMs>0)
    {
      ms:=Time[2]-mod(ValueMs,1000)
      if (ms<0)
      {
        ms+=1000
        m:=1
      }
      t:=DateAdd(Time[1],-(Floor(ValueMs/1000)+m),"Seconds")
    }
    else
    {
      ms:=mod(-ValueMs,1000)+Time[2]
      if (ms>999)
      {
        ms-=1000
        m:=1
      }
      t:=DateAdd(Time[1],Floor(-ValueMs/1000)+m,"Seconds")
    }
    return [t,format("{:03}",ms)]
  }
  TimeAddMs(Time,ValueMs)
  {
    ValueMs:=round(ValueMs)
    T:=DateAdd(Time[1],ValueMs//1000,"Seconds")
    ms:=Time[2]+mod(ValueMs,1000)
    if (ms>999)
    {
      ms-=1000
      T:=DateAdd(T,1,"Seconds")
    }
    return [T,format("{:03}",ms)]
  }
  TimeToMs(Time)
  {
    HH:=FormatTime(Time,"HH")
    MM:=FormatTime(Time,"mm")
    SS:=FormatTime(Time,"ss")
    return HH*3600000+MM*60000+SS*1000
  }
  MsToTime(Ms)
  {
    T:=DateAdd(1601,Ms//1000,"Seconds")
    Ms:=format("{:03}",mod(Ms,1000))
    return [T,Ms]
  }

  TTOk(*)
  {
    ToTime:=this.hTT.Value
    tmp1:=DateDiff(A_Now,ToTime,"Seconds")
    this.XTOffset:=tmp1*1000-round((this.GPosW/2)/this.PerioT)
    this.Pause:=true
    this.ShiftStrt:=true
    this.GuiGoToT.Hide()
  }
  TTCancel(*)
  {
    this.GuiGoToT.Hide()
  }
  TXOk(*)
  {
    this.X_Offset:=this.ArrSize[this.Sel]-this.hTX.Value
    this.Pause:=true
    this.GuiGoToX.Hide()
  }
  TXCancel(*)
  {
    this.GuiGoToX.Hide()
  }
  NameOk(*)
  {
    this.ArrName[this.Sel]:=this.GuiNameVal.Value
    this.GuiName.Hide()
  }
  NameCancel(*)
  {
    this.GuiName.Hide()
  }
  ValAcc(*)
  {
    if (this.WhichVal="")
      return
    Whichval:=this.Whichval
    if (Whichval="YScale")
    {
      this.%Whichval%[this.Sel]:=this.GuiValVal.Value
      this.AutoScale[this.Sel]:=false
      if this.OScale
        loop this.AutoScale.Length
          this.AutoScale[a_index]:=this.AutoScale[this.Sel]
    }
    else if (Whichval="ZoomX")
    {
      this.%Whichval%:=round(this.GuiValVal.Value)
    }
    else if (Whichval="ZoomT")
    {
      this.%Whichval%:=round(this.GuiValVal.Value*60000)
    }
    else if (Whichval="FontSize")
    {
      this.%Whichval%:=this.GuiValVal.Value
      if (this.FontSize!=this.prevSize)
        this.SetFont(,this.FontSize)
    }
    else if (Whichval="Transp")
    {
      this.%Whichval%[this.Sel]:=round(this.GuiValVal.Value)&0xff
      this.Pen[this.Sel]:=this.Transp[this.Sel]<<24|this.Pen[this.Sel]&0xffffff
    }
    else if (Whichval="UpdatePeriod")
    {
      this.UpdatePeriod:=this.GuiValVal.Value
      settimer this.UpdateTimer,this.UpdatePeriod
    }
    else if (Whichval!="")
    {
      if (isObject(this.%Whichval%))
        this.%Whichval%[this.Sel]:=this.GuiValVal.Value
      else
        this.%Whichval%:=this.GuiValVal.Value
    }
  }
  ValOk(*)
  {
    this.ValAcc()
    this.WhichVal:=""
    this.GuiVal.Hide()
  }
  ValCancel(*)
  {
    this.WhichVal:=""
    this.GuiVal.Hide()
  }
  HelpClose(*)
  {
    this.GuiHelp.Hide()
  }

  MenuVal(*)
  {
    this.GuiVal.Show()
  }
  MenuFlFt(*)
  {
    this.WhichVal:="FloatFormat"
    this.GuiValText1.Value:="Количество знаков после запятой"
    this.GuiValVal.Value:=this.FloatFormat
    this.GuiValText2.Value:=""
    this.MenuVal()
  }
  MenuUpdPrd(*)
  {
    this.WhichVal:="UpdatePeriod"
    this.GuiValText1.Value:="Период обновления окна графика"
    this.GuiValVal.Value:=this.UpdatePeriod
    this.GuiValText2.Value:="ms"
    this.MenuVal()
  }
  MenuName(*)
  {
    this.GuiNameVal.Value:=this.ArrName[this.Sel]
    this.GuiName.Show()
  }
  MenuGColor(*)
  {
    tmp1:=ChooseColor(this.Pen[this.Sel],this.GuiGraph.Hwnd)
    if (tmp1!="")
    {
      tmp2:=this.RGBToHSV(tmp1)
      if ((tmp2>>8)&0xff=0)
      {
        tmp3:=(tmp2&0xff)
        if (tmp3<127)
          tmp3:=127
        this.Hue[this.Sel]:=tmp3<<8
      }
      else
        this.Hue[this.Sel]:=tmp2>>16
      this.Pen[this.Sel]:=0xff000000 | tmp1
    }
  }
  MenuHelp(*)
  {
    this.GuiHelp.Show()
  }
  MenuGoTo(*)
  {
    if this.ScaleXByTime
    {
      this.GuiGoToT.Show()
    }
    else
    {
      this.GuiGoToX.Show()
    }
  }
  MenuClose(*)
  {
    this.Hide()
  }
  MenuPause(*)
  {
    this.Pause:=!this.Pause
  }
  MenuForward(*)
  {
    this.Pause:=false
    this.XTOffset:=0
    this.X_Offset:=0
    this.ShiftStrt:=true
  }
  MenuBackward(*)
  {
    this.Pause:=true
    this.X_Offset:=this.ArrSize[this.Sel]-this.ZoomX//2
    if this.ScaleXByTime
    {
      if this.TimeStampExist[this.Sel]
        tmp1:=DateDiff(A_Now,this.pData[1][2],"Seconds")
      else
        tmp1:=DateDiff(A_Now,this.StampT[this.Sel][1][1],"Seconds")
      this.XTOffset:=tmp1*1000-this.ZoomT//2
    }
    this.ShiftStrt:=true
  }
  MenuMarkers(*)
  {
    Add:=this.Pos.H*8
    if this.ShowMarkers:=!this.ShowMarkers
    {
      Size:=100+Add
      this.GuiGraph.Opt("+MinSize300x" Size)
      this.GuiGraph.GetPos(,,,&BPosH)
      this.GuiGraph.Move(,,,BPosH+Add)
      this.MarkerOffset:=Add
    }
    else
    {
      this.GuiGraph.Opt("+MinSize300x100")
      this.GuiGraph.GetPos(,,,&BPosH)
      this.GuiGraph.Move(,,,BPosH-Add)
      this.MarkerOffset:=0
    }
  }
  MenuAutoScale(*)
  {
    if (this.Lock_hi_lim[this.Sel] or this.Lock_lo_lim[this.Sel])
      this.AutoScale[this.Sel]:=false
    if this.AutoScale[this.Sel]:=!this.AutoScale[this.Sel]
    {
      this.Lock_hi_lim[this.Sel]:=false
      this.Lock_lo_lim[this.Sel]:=false
      this.GraphMenuSettings.check(this.mi.MenuAutoScale)
    }
    else
      this.GraphMenuSettings.uncheck(this.mi.MenuAutoScale)
  }
  MenuAlwaysOnTop(*)
  {
    if this.AlwaysOnTop:=!this.AlwaysOnTop
    {
      this.GuiGraph.Opt("+alwaysontop")
      this.GraphMenuSettings.check(this.mi.MenuAlwaysOnTop)
    }
    else
    {
      this.GuiGraph.Opt("-alwaysontop")
      this.GraphMenuSettings.uncheck(this.mi.MenuAlwaysOnTop)
    }
  }
  MenuSmooth(*)
  {
    if this.Smooth[this.Sel]:=!this.Smooth[this.Sel]
      this.GraphMenuSettings.check(this.mi.MenuSmooth)
    else
      this.GraphMenuSettings.uncheck(this.mi.MenuSmooth)
  }
  MenuScaleXByTime(*)
  {
    this.ScaleXByTime:=true
    this.GraphMenuSettings.check(this.mi.MenuScaleXByTime)
    this.GraphMenuSettings.uncheck(this.mi.MenuScaleXByDots)
  }
  MenuScaleXByDots(*)
  {
    this.ScaleXByTime:=false
    this.GraphMenuSettings.uncheck(this.mi.MenuScaleXByTime)
    this.GraphMenuSettings.check(this.mi.MenuScaleXByDots)
  }
  MenuResetFont(*)
  {
    this.FontSize:=12
    this.SetFont(,this.FontSize)
  }
  MenuSave(*)
  {
    SaveFileName:=FileSelect("S 16",,"Сохранить данные графика","(*.garr)")
    if (SaveFileName!="")
    {
      if !InStr(SaveFileName,".garr")
        SaveFileName.=".garr"
      o:=this.Data.Clone()
      o.Push(this.CreateTime)
      o.Push(this.ArrName)
      tooltip "Сохраняется..."
      ObjDump(SaveFileName,o)
      tooltip
      msgbox "Сохранено."
    }
  }
  MenuLoad(*)
  {
    SaveFileName:=FileSelect(3,,"Загрузить данные графика для просмотра","(*.garr)")
    if (SaveFileName!="")
      this.LoadFile(SaveFileName)
  }
  DropFiles(GuiObj,GuiCtrlObj,FileArray,X,Y)
  {
    if instr(FileArray[1],".garr")
      this.LoadFile(FileArray[1])
  }
  LoadFile(File)
  {
    o:=ObjLoad(File)
    this.SaveArrName:=this.ArrName.Clone()
    this.ArrName:=[]
    for v in o[o.Length]
    {
      if !isobject(v) and !isNumber(V)
      {
        this.ArrName:=o.Pop()
        this.CreateTime:=o.Pop()
        break
      }
    }
    this.NewData:=o
    this.MenuBackward()
    this.Pause:=true
    this.Loaded:=1
  }
  UpdateMenu()
  {
    if this.AutoScale[this.Sel]
      this.GraphMenuSettings.check(this.mi.MenuAutoScale)
    else
      this.GraphMenuSettings.uncheck(this.mi.MenuAutoScale)
    if this.Smooth[this.Sel]
      this.GraphMenuSettings.check(this.mi.MenuSmooth)
    else
      this.GraphMenuSettings.uncheck(this.mi.MenuSmooth)
  }

  AHSVToARGB(a:=255,h:=0,s:=0,v:=0)
  {
    H:=h/255
    S:=s/255
    V:=v/255
    i:=Floor(H*6)
    f:=H*6-i
    p:=V*(1-S)
    q:=V*(1-f*S)
    t:=V*(1-(1-f)*S)
    sw:=mod(i,6)
    if (sw=0)
      r:=V, g:=t, b:=p
    if (sw=1)
      r:=q, g:=V, b:=p
    if (sw=2)
      r:=p, g:=V, b:=t
    if (sw=3)
      r:=p, g:=q, b:=V
    if (sw=4)
      r:=t, g:=p, b:=V
    if (sw=5)
      r:=V, g:=p, b:=q
    r:=(Integer(r*255))&0xff
    g:=(Integer(g*255))&0xff
    b:=(Integer(b*255))&0xff
    return (a<<24 | r<<16 | g<<8 | b)
  }
  RGBToHSV(RGB)
  {
    r:=(RGB>>16 & 0xff)/255
    g:=(RGB>>8 & 0xff)/255
    b:=(RGB & 0xff)/255
    min:=(r<g)?((r<b)?r:b):((g<b)?g:b)
    val:=(r>g)?((r>b)?r:b):((g>b)?g:b)
    delta:=val-min
    if (delta=0) ;pure blackness
      return (RGB & 0xff)
    if (r=val) ;between yellow and magenta
      hue:=(g-b)/delta
    else if (g=val) ;between cyan and yellow
      hue:=2+(b-r)/delta
    else ;between magenta and cyan
      hue:=4+(r-g)/delta
    if (hue<=0)
      hue+=6
    hue:=round(hue/6*255)
    sat:=round((Delta/val)*255)
    val:=round(val*255)
    return (hue<<16 | sat<<8 | val)
  }
  Show(x:="",y:="",w:="",h:="",NewName:="",NewUP:="")
  {
    if NewName
      this.Name:=NewName
    if IsInteger(NewUP)
      this.UpdatePeriod:=NewUP
    this.GuiHiden:=false
    this.GuiGraph.Title:=this.Name
    this.GuiGraph.Show((x=""?"":"x" x " ") . (y=""?"":"y" y " ") . (w=""?"":"w" w " ") . (h=""?"":"h" h " "))
    if !this.SetParentOnce
    {
      this.SetParentOnce:=true
      DllCall("SetParent","Ptr",this.GuiGDIP.hwnd,"Ptr",this.GuiGraph.hwnd)
      WinMove(0,0,,,"ahk_id " this.GuiGDIP.hwnd)
      this.GuiGraph.Show()
    }
    settimer this.UpdateTimer,this.UpdatePeriod
  }

  Hide(*)
  {
    this.GuiHiden:=true
    settimer this.UpdateTimer,0
    this.Update(0)
    this.GuiGraph.Hide()
    if this.IsChild
      this.Parent.DeleteChild(this.IsChild)
  }
  DeleteChild(Num)
  {
    loop this.Child.Length
    {
      if (this.Child[a_index].IsChild=Num)
      {
        ObjAddRef(ObjPtr(this))
        this.Child[a_index]:=""
        this.Child.RemoveAt(a_index)
        break
      }
    }
  }

  Create()
  {
    this.hDC:=DllCall("CreateCompatibleDC","UPtr",0)
    bi:=Buffer(40,0)
    NumPut("UInt",40,bi,0)
    NumPut("UInt",A_ScreenWidth,bi,4)
    NumPut("UInt",A_ScreenHeight,bi,8)
    NumPut("UShort",1,bi,12)
    NumPut("UShort",32,bi,14)
    NumPut("UInt",0,bi,16)
    this.hBitmap:=DllCall("CreateDIBSection"
                    ,"Ptr",this.hDC
                    ,"Ptr",bi.Ptr
                    ,"uint",0
                    ,"UPtr*",0
                    ,"Ptr",0
                    ,"uint",0,"Ptr")
    this.obm:=DllCall("SelectObject","Ptr",this.hDC,"Ptr",this.hBitmap)
    DllCall(Graph.hGdipCreateFromHDC,"Ptr",this.hDC,"UPtr*",&pGraphics:=0)
    this.pGraphics:=pGraphics
    DllCall(Graph.hGdipSetSmoothingMode,"UPtr",this.pGraphics,"Int",4)
  }

  Update(Alpha:=255)
  {
    WinGetClientPos(,,&GPosW,&GPosH,this.GuiGraph.hwnd)
    this.GPosW:=GPosW
    this.GPosH:=GPosH-this.StampOffset-this.MarkerOffset-this.MenuOffset
    this.ZeroPosU:=this.GPosH-this.ZeroPos
    if (this.ZeroPosU<0 and this.GPosH_!=GPosH)
    {
      this.ZeroPos:=GPosH//2
      this.ZeroPosU:=this.GPosH-this.ZeroPos
    }
    this.GPosH_:=GPosH
    pt:=Buffer(8,0)
    DllCall("UpdateLayeredWindow"
            ,"Ptr",this.GuiGDIP.Hwnd
            ,"Ptr",0
            ,"Ptr",pt.Ptr
            ,"UInt*",GPosW|GPosH<<32
            ,"Ptr",this.hDC
            ,"int64*",0
            ,"uint",0
            ,"UInt*",Alpha<<16|1<<24
            ,"uint",2)
  }

  CreateSolidBrush(ARGB:=0xff000000)
  {
    DllCall(Graph.hGdipCreateSolidFill,"UInt",ARGB,"UPtr*",&pBrush:=0)
    return pBrush
  }
  DeleteBrush(pBrush)
  {
    DllCall(Graph.hGdipDeleteBrush,"UPtr",pBrush)
    return 0
  }
  CreatePen(ARGB:=0xff000000,w:=1)
  {
    DllCall(Graph.hGdipCreatePen1,"UInt",ARGB,"float",w,"int",2,"UPtr*",&pPen:=0)
    return pPen
  }
  DeletePen(pPen)
  {
    DllCall(Graph.hGdipDeletePen,"UPtr",pPen)
    return 0
  }

  FillRectangle(ARGB,x,y,w,h)
  {
    if (!this.pBrush or this.prevBrushColor!=ARGB)
    {
      if this.pBrush
        this.pBrush:=this.DeleteBrush(this.pBrush)
      this.pBrush:=this.CreateSolidBrush(ARGB)
    }
    this.prevBrushColor:=ARGB
    DllCall(Graph.hGdipFillRectangle
            ,"Ptr",this.pGraphics
            ,"Ptr",this.pBrush
            ,"float",x
            ,"float",y
            ,"float",w
            ,"float",h)
    return {X:x,Y:y,W:w,H:h}
  }
  DrawLine(ARGB,x1,y1,x2,y2,LineWidth:=1)
  {
    if (!this.pPen or this.prevPenColor!=ARGB or this.OldLineWidth!=LineWidth)
    {
      if this.pPen
        this.pPen:=this.DeletePen(this.pPen)
      this.pPen:=this.CreatePen(ARGB,LineWidth)
    }
    this.OldLineWidth:=LineWidth
    this.prevPenColor:=ARGB
    DllCall(Graph.hGdipDrawLine
            ,"Ptr",this.pGraphics
            ,"Ptr",this.pPen
            ,"float",x1
            ,"float",y1
            ,"float",x2
            ,"float",y2)
    return {X1:x1,Y1:y1,X2:x2,Y2:y2}
  }
  DrawLines(ARGB,Points,LineWidth:=1)
  {
    tmp1:=Points.Length
    if !tmp1
      return -1
    PointF:=Buffer(8*tmp1)
    Loop tmp1
    {
      NumPut("float",Points[a_index][1],PointF,8*(A_Index-1))
      NumPut("float",Points[a_index][2],PointF,(8*(A_Index-1))+4)
    }

    if (!this.pPen or this.prevPenColor!=ARGB or this.OldLineWidth!=LineWidth)
    {
      if this.pPen
        this.pPen:=this.DeletePen(this.pPen)
      this.pPen:=this.CreatePen(ARGB,LineWidth)
    }
    this.OldLineWidth:=LineWidth
    this.prevPenColor:=ARGB
    return DllCall(Graph.hGdipDrawLines
                  ,"Ptr",this.pGraphics
                  ,"Ptr",this.pPen
                  ,"Ptr",PointF.Ptr
                  ,"int",tmp1)
  }
  DrawEllipse(ARGB,x,y,w,h,LineWidth:=1)
  {
    if (!this.pPen or this.prevPenColor!=ARGB or this.OldLineWidth!=LineWidth)
    {
      if this.pPen
        this.pPen:=this.DeletePen(this.pPen)
      this.pPen:=this.CreatePen(ARGB,LineWidth)
    }
    this.OldLineWidth:=LineWidth
    this.prevPenColor:=ARGB
    DllCall(Graph.hGdipDrawEllipse
              ,"Ptr",this.pGraphics
              ,"Ptr",this.pPen
              ,"float",x
              ,"float",y
              ,"float",w
              ,"float",h)
    return {X:x,Y:y,W:w,H:h}
  }
  DrawRectangle(ARGB,x,y,w,h,LineWidth:=1)
  {
    if (!this.pPen or this.prevPenColor!=ARGB or this.OldLineWidth!=LineWidth)
    {
      if this.pPen
        this.pPen:=this.DeletePen(this.pPen)
      this.pPen:=this.CreatePen(ARGB,LineWidth)
    }
    this.OldLineWidth:=LineWidth
    this.prevPenColor:=ARGB
    DllCall(Graph.hGdipDrawRectangle
                ,"Ptr",this.pGraphics
                ,"Ptr",this.pPen
                ,"float",x
                ,"float",y
                ,"float",w
                ,"float",h)
    return {X:x,Y:y,W:w,H:h}
  }

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

    if (!this.hFormat
   or (this.prevNoWrap!=NoWrap and NoWrap!="")
   or (this.prevVertical!=Vertical and Vertical!=""))
    {
      if this.hFormat
      {
        DllCall(Graph.hGdipDeleteStringFormat,"UPtr",this.hFormat)
        this.hFormat:=""
      }
      Flags:=0x4000
      Flags:=NoWrap?(Flags|0x1000):Flags
      Flags:=Vertical?(Flags|0x2):Flags
      DllCall(Graph.hGdipCreateStringFormat,"int",Flags,"int",0,"UPtr*",&hFormat:=0)
      this.hFormat:=hFormat
      this.prevNoWrap:=NoWrap
      this.prevVertical:=Vertical
    }

    if (!this.hFamily or (this.prevFont!=Font and Font!=""))
    {
      if this.hFamily
      {
        if this.hFont
        {
          DllCall(Graph.hGdipDeleteFont,"UPtr",this.hFont)
          this.hFont:=""
        }
        DllCall(Graph.hGdipDeleteFontFamily,"UPtr",this.hFamily)
        this.hFamily:=""
      }
      Font:=Font="" ? "Arial" : Font
;      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(Graph.hGdipCreateFontFamilyFromName
;              ,"Ptr",A_IsUnicode ? &Font : &wFont
;              ,"uint",0
;              ,"UPtr*",hFamily)
      DllCall(Graph.hGdipCreateFontFamilyFromName
              ,"Ptr",StrPtr(String(Font))
              ,"uint",0
              ,"UPtr*",&hFamily:=0)
      this.hFamily:=hFamily
      this.prevFont:=Font
    }

    if (!this.hFont or (this.prevSize!=Size and Size!="") or (this.prevfStyle!=fStyle and fStyle!=""))
    {
      if this.hFont
      {
        DllCall(Graph.hGdipDeleteFont,"UPtr",this.hFont)
        this.hFont:=""
      }
      DllCall(Graph.hGdipCreateFont
    ,"UPtr",this.hFamily
    ,"float",(Size ? Size : 12)
    ,"int",fStyle="" ? 0 : Style
    ,"int",0
    ,"UPtr*",&hFont:=0)
      this.hFont:=hFont
      this.prevSize:=Size
      this.prevfStyle:=fStyle
    }

    RenderingHint:=(RenderingHint="") ? ((this.prevRenderingHint="") ? 0 : this.prevRenderingHint) : RenderingHint
    this.prevRenderingHint:=RenderingHint
    ; SystemDefault = 0
    ; SingleBitPerPixelGridFit = 1
    ; SingleBitPerPixel = 2
    ; AntiAliasGridFit = 3
    ; AntiAlias = 4
    DllCall(Graph.hGdipSetTextRenderingHint,"UPtr",this.pGraphics,"int",RenderingHint)
  }

  DrawString(Text,xpos:=0,ypos:=0,Width:=0,Height:=0,Options:="Center",Colour:=0xff000000,BackgroundColour:=0)
  {
    if !(this.hFamily and this.hFont and this.hFormat)
      this.SetFont()

    Align:=0
    Loop Parse "Near|Left|Centre|Center|Far|Right","|"
    {
      if RegExMatch(Options, "\b" A_loopField)
        Align|=Floor(A_Index/2.1)      ; 0|0|1|1|2|2
    }
    DllCall(Graph.hGdipSetStringFormatAlign,"UPtr",this.hFormat,"int",Align)

    if (!this.FontpBrush or Colour!=this.prevColour)
    {
      if this.FontpBrush
        this.FontpBrush:=this.DeleteBrush(this.FontpBrush)
      this.FontpBrush:=this.CreateSolidBrush(Colour)
      this.prevColour:=Colour
    }

    RC:=this.CreateRectF(xpos,ypos,Width,Height)
    ReturnRC:=this.MeasureString(Text,RC)
    if (!Width or !Height)
    {
      Width:=Width ? Width : ReturnRC.W
      Height:=Height ? Height : ReturnRC.H
      RC:=this.CreateRectF(xpos,ypos,Width,Height)
      ReturnRC:=this.MeasureString(Text,RC)
    }
    if BackgroundColour
      this.FillRectangle(BackgroundColour,xpos,ypos,Width,Height)
    RegExMatch(Options,"i)Top|Up|Bottom|Down|vCentre|vCenter",&vPos)
    if vPos
    {
      vPos:=SubStr(Options,vPos.Pos,vPos.Len)
      if (vPos="vCentre" or vPos="vCenter")
        ypos+=(Height-ReturnRC.H)//2
      else if (vPos="Top" or vPos="Up")
        ypos:=ReturnRC.Y
      else if (vPos="Bottom" or vPos="Down")
        ypos+=Height-ReturnRC.H

      RC:=this.CreateRectF(xpos,ypos,Width,ReturnRC.H)
      ReturnRC:=this.MeasureString(Text,RC)
    }

;    sString:=Text
;    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)
;    }
;    DllCall(Graph.hGdipDrawString
;            ,"Ptr",this.pGraphics
;            ,"Ptr",A_IsUnicode ? &sString : &wString
;            ,"int",-1
;            ,"Ptr",this.hFont
;            ,"Ptr",&RC
;            ,"Ptr",this.hFormat
;            ,"Ptr",this.FontpBrush)
    DllCall(Graph.hGdipDrawString
            ,"Ptr",this.pGraphics
            ,"Ptr",StrPtr(String(Text))
            ,"int",-1
            ,"Ptr",this.hFont
            ,"Ptr",RC.Ptr
            ,"Ptr",this.hFormat
            ,"Ptr",this.FontpBrush)
    return ReturnRC
  }
  CreateRectF(x,y,w,h)
  {
    RectF:=Buffer(16)
    NumPut("float",x,RectF,0)
    NumPut("float",y,RectF,4)
    NumPut("float",w,RectF,8)
    NumPut("float",h,RectF,12)
    return RectF
  }

  MeasureString(sString,RectF)
  {
    RC:=Buffer(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)
;    }
;    if !DllCall(Graph.hGdipMeasureString
;            ,"Ptr",this.pGraphics
;            ,"Ptr",A_IsUnicode ? &sString : &wString
;            ,"int",-1
;            ,"Ptr",this.hFont
;            ,"Ptr",&RectF
;            ,"Ptr",this.hFormat
;            ,"Ptr",&RC
;            ,"uint*",Chars
;            ,"uint*",Lines)
    if !DllCall(Graph.hGdipMeasureString
            ,"Ptr",this.pGraphics
            ,"Ptr",StrPtr(String(sString))
            ,"int",-1
            ,"Ptr",this.hFont
            ,"Ptr",RectF.Ptr
            ,"Ptr",this.hFormat
            ,"Ptr",RC.Ptr
            ,"uint*",&Chars:=0
            ,"uint*",&Lines:=0)
    return	{X:Ceil(NumGet(RC,0,"float"))
    ,Y:Ceil(NumGet(RC,4,"float"))
    ,W:Ceil(NumGet(RC,8,"float"))
    ,H:Ceil(NumGet(RC,12,"float"))
    ,Chars:Chars
    ,Lines:Lines}
  }
}

#HotIf WinActive("ahk_class AutoHotkeyGUI",Graph.WinText)
WheelUp::
{
  MouseGetPos(,,&mW)
  Graph.WheelUp:=true
  Graph.HotKeymW:=mW
}
WheelDown::
{
  MouseGetPos(,,&mW)
  Graph.WheelDown:=true
  Graph.HotKeymW:=mW
}
#HotIf



/*  Windows Color Picker Plus
    https-//autohotkey.com/board/topic/91229-windows-color-picker-plus/
    Edited by me lemasato-
        BGR2RGB()-
        Use Format() to convert the value to hex instead of SetFormat

    Function- ChooseColor([pRGB, hOwner, DlgX, DlgY, Palette])
        Displays a standard Windows dialog for choosing colors.
    Parameters-
        pRGB - The initial color to display in the dialog in RGB format.
              The default setting is Black.
        hOwner - The Window ID of the dialog's owner, if it has one. Defaults to
                0, i.e. no owner. If specified DlgX and DlgY are ignored.
        DlgX, DlgY - The X and Y coordinates of the upper left corner of the
                    dialog. Both default to 0.
        Palette - An array of up to 16 RGB color values. These become the
                  initial custom colors in the dialog.
    Remarks-
        The custom colors in the dialog are remembered between calls.

        If the user selects OK, the Palette array (if it exists) will be loaded
        with the custom colors from the dialog.
    Returns-
        If the user selects OK, the selected color is returned in RGB format
        and ErrorLevel is set to 0. Otherwise, the original pRGB value is
        returned and ErrorLevel is set to 1.
*/

ChooseColor(pRGB:=0,hOwner:=0,DlgX:=0,DlgY:=0)
{
  static CustColors:=Buffer(64,0)    ; Custom colors are remembered between calls
  static SizeOfCustColors:=CustColors.size
  static ChooseColor:=Buffer(9*A_PtrSize,0)
  static StructSize:=ChooseColor.size
  static Palette:=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]

  CustData:=(DlgX<<16)|DlgY    ; Store X in high word, Y in the low word

;___Load user's custom colors
  loop 16
    NumPut("UInt",BGR2RGB(Palette[a_index]),CustColors,(A_Index-1)*4)

;___Set up a ChooseColor structure as described in the MSDN
  NumPut("UInt",StructSize,ChooseColor,0)
  NumPut("UPtr",hOwner,ChooseColor,A_PtrSize)
  NumPut("UInt",BGR2RGB(pRGB),ChooseColor,3*A_PtrSize)
  NumPut("UPtr",CustColors.Ptr,ChooseColor,4*A_PtrSize)
  NumPut("UInt",0x113,ChooseColor,5*A_PtrSize)
  NumPut("UInt",CustData,ChooseColor,6*A_PtrSize)
  NumPut("UPtr",CallbackCreate(ColorWindowProc),ChooseColor,7*A_PtrSize)

;___Call the function
  ErrorLevel:=!DllCall("comdlg32\ChooseColor","UPtr",ChooseColor.Ptr,"UInt")

;___Save the changes made to the custom colors
  if !ErrorLevel
    Loop 16
      Palette[A_Index]:=BGR2RGB(NumGet(CustColors,(A_Index-1)*4,"UInt"))
  if !ErrorLevel ; modified by Alectric
    return BGR2RGB(NumGet(ChooseColor,3*A_PtrSize,"UINT"))
}

/*!
    Function- ColorWindowProc(hwnd, msg, wParam, lParam)
        Callback function used to modify the Color dialog before it is displayed
    Parameters-
        hwnd - Handle to the Color dialog window.
        msg - The message sent to the window.
        wParam - The handle to the control that has the keyboard focus.
        lParam - A pointer to the ChooseColor structure associated with the
                Color dialog.
    Remarks-
        This is intended to be a private function, called only by ChooseColor.
        In response to a WM_INITDIALOG message, this function can be used to
        modify the Color dialog before it is displayed. Currently it just moves
        the window to a new X, Y location.
    Returns-
        If the hook procedure returns zero, the default dialog box procedure
        also processes the message. Otherwise, the default dialog box procedure
        ignores the message.
*/
ColorWindowProc(hwnd,msg,wParam,lParam)
{
  static WM_INITDIALOG:=0x0110

  if (msg!=WM_INITDIALOG)
    return 0

  hOwner:=NumGet(lParam,A_PtrSize,"UPtr")
  if hOwner
    return 0

  DetectSetting:=A_DetectHiddenWindows
  DetectHiddenWindows true
  CustData:=NumGet(lParam,6*A_PtrSize,"UInt")
  DlgX:=CustData>>16
  DlgY:=CustData&0xFFFF
  WinMove DlgX,DlgY,,,"ahk_id " hwnd

  DetectHiddenWindows DetectSetting
  return 0
}

/*!
    Function- BGR2RGB(Color)
        Converts a BGR color value to a RGB one or vice versa.
    Parameters-
        Color - The BGR or RGB value to convert
    Returns-
        The converted value.
*/
BGR2RGB(Color)
{
  ret:=  (Color & 0xFF000000)
      |((Color & 0x00FF0000)>>16)
      | (Color & 0x0000FF00)
      |((Color & 0x000000FF)<<16)
  return ret
}

ObjLoad(addr,&offset:=0) ; load dumped object to variable; from memory (addr is int) or from file (addr is string)
{
  ; #requires AutoHotkey v2.0.19
  If !IsNumber(addr)
  {
    If !FileExist(addr)
      return
    sz:=FileGetSize(addr)
    If !sz
      return
    Data:=FileRead(addr,"RAW")
    addr:=Data.Ptr
    sz:=NumGet(addr,"Int64")
    addr+=8
    obj:=0
  }
  ;    Sizes          1       1       2        2     4      4       8        8        8    x     x     x      x         x
  ;    Type.Enum: Char.1 UChar.2 Short.3 UShort.4 Int.5 UInt.6 Int64.7 UInt64.8 Double.9 Str.10 [].11 {}.12 map().13 buffer.14
  static types:=["Char","UChar","Short","UShort","Int","UInt","Int64","UInt64","Double"]
  static syzes:=[     2,      2,      3,       3,    5,     5,      9,       9,       9]
  typ:=NumGet(addr,offset,"Char")
  if (typ<10)
  {
    obj:=NumGet(addr,offset+1,types[typ])
    offset+=syzes[typ]
  }
  else if (typ=10)
  {
    size:=NumGet(addr,offset+1,"Int64")
    obj:=StrGet(addr+offset+9,size)
    offset+=9+size
  }
  else if (typ=11)
  {
    obj:=[]
    size:=NumGet(addr,offset+1,"Int64")
    obj.Length:=size
    offset+=9
    loop size
      obj[a_index]:=ObjLoad(addr,&offset)
  }
  else if (typ=12)
  {
    obj:={}
    Props:=NumGet(addr,offset+1,"Int64")
    offset+=9
    loop Props
    {
      k:=ObjLoad(addr,&offset)
      obj.%k%:=ObjLoad(addr,&offset)
    }
  }
  else if (typ=13)
  {
    obj:=Map()
    Props:=NumGet(addr,offset+1,"Int64")
    Items:=NumGet(addr,offset+9,"Int64")
    offset+=17
    loop Props
    {
      k:=ObjLoad(addr,&offset)
      obj.%k%:=ObjLoad(addr,&offset)
    }
    loop Items
    {
      i:=ObjLoad(addr,&offset)
      obj[i]:=ObjLoad(addr,&offset)
    }
  }
  else if (typ=14)
  {
    size:=NumGet(addr,offset+1,"Int64")
    obj:=Buffer(size)
    offset+=9
    loop size
      NumPut("UChar",NumGet(addr,offset+a_index-1,"UChar"),obj,a_index-1)
    offset+=size
  }
  return obj
}

ObjDump(Path,obj) ; dump object to file
{
  critical
  ; #requires AutoHotkey v2.0.19
  if !sz:=RawObjectSize(obj)
    return
  If FileExist(Path)
    FileDelete Path
  sz+=8
  Data:=Buffer(sz,0)
  ptr:=Data.Ptr
  NumPut("Int64",sz-8,ptr) ;size of all data
  RawObject(obj,ptr+8) ; use this for dumping to memory instead of ObjDump
  f:=FileOpen(Path,"rw-rwd","CP0")
  Loop (sz//65536)
    f.RawWrite(ptr,65536),ptr+=65536
  f.RawWrite(ptr,Mod(sz,65536))
  f.Close()
  return sz
}
RawObject(obj,ptr,offset:=0) ; dump object to memory
{
  ; #requires AutoHotkey v2.0.19
  ;    Sizes          1       1       2        2     4      4       8        8        8    x     x     x      x         x
  ;    Type.Enum: Char.1 UChar.2 Short.3 UShort.4 Int.5 UInt.6 Int64.7 UInt64.8 Double.9 Str.10 [].11 {}.12 map().13 buffer.14
  if isObject(Obj)
  {
    if (Obj.base=[].base)
    {
      NumPut("Char",11,ptr,offset) ; type
      NumPut("Int64",Obj.Length,ptr,offset+1) ; Length of array
      offset+=9
      loop Obj.Length
        offset:=RawObject(Obj[a_index],ptr,offset)
    }
    else if (Obj.base={}.base)
    {
      NumPut("Char",12,ptr,offset) ; type
      NumPut("Int64",ObjOwnPropCount(Obj),ptr,offset+1) ; num of Props
      offset+=9
      for k,v in Obj.OwnProps()
      {
        offset:=RawObject(k,ptr,offset) ; name of prop (str)
        offset:=RawObject(v,ptr,offset) ; value of prop (any)
      }
    }
    else if (Obj.base=Map().base)
    {
      NumPut("Char",13,ptr,offset) ; type
      NumPut("Int64",ObjOwnPropCount(Obj),ptr,offset+1) ; num of Props
      NumPut("Int64",Obj.Count,ptr,offset+9) ; num of items
      offset+=17
      for k,v in Obj.OwnProps()
      {
        offset:=RawObject(k,ptr,offset) ; name of prop (str)
        offset:=RawObject(v,ptr,offset) ; value of prop (any)
      }
      for k,v in Obj
      {
        offset:=RawObject(k,ptr,offset) ; index of item (any)
        offset:=RawObject(v,ptr,offset) ; value of item (any)
      }
    }
    else if (Obj.base=Buffer().base)
    {
      NumPut("Char",14,ptr,offset) ; type
      NumPut("Int64",Obj.size,ptr,offset+1) ; num of bytes
      offset+=9
      loop Obj.size
        NumPut("UChar",NumGet(Obj,a_index-1,"UChar"),ptr,offset+a_index-1) ; Buffer content (RAW)
      offset+=Obj.size
    }
  }
  else if IsNumber(obj) ; num
  {
    NumPut("Char",IsFloat(Obj)?9:Obj>4294967295?8       :Obj>65535?6     :Obj>255?4       :Obj>-1?2      :Obj>-129?1     :Obj>-32769?3      :Obj>-2147483649?5    :7,ptr,offset+0)
    NumPut(IsFloat(Obj)?"Double":Obj>4294967295?"UInt64":Obj>65535?"UInt":Obj>255?"UShort":Obj>-1?"UChar":Obj>-129?"Char":Obj>-32769?"Short":Obj>-2147483649?"Int":"Int64",Obj,ptr,offset+1)
    offset+=       IsFloat(Obj)||Obj>4294967295?9       :Obj>65535?5     :Obj>255?3                      :Obj>-129?2     :Obj>-32769?3      :Obj>-2147483649?5    :9
  }
  else ; string
  {
    NumPut("Char",10,ptr,offset)  ; type
    NumPut("Int64",sz:=StrPut(Obj,ptr+offset+9),ptr,offset+1) ; (str size) string text
    offset+=sz+9
  }
  return offset
}

RawObjectSize(Obj,sz:=0) ; get object's size in dumped condition
{
  ; #requires AutoHotkey v2.0.19
  if isObject(Obj)
  {
    if (Obj.base=[].base)
    {
      sz+=9 ; 1 (type) + 8 (num of items)
      loop Obj.Length
        sz:=RawObjectSize(Obj[a_index],sz)
    }
    else if (Obj.base={}.base)
    {
      sz+=9 ; 1 (type) + 8 (num of prop)
      for k,v in Obj.OwnProps()
      {
        sz:=RawObjectSize(k,sz) ; name of prop (str)
        sz:=RawObjectSize(v,sz) ; value of prop (any)
      }
    }
    else if (Obj.base=Map().base)
    {
      sz+=17 ; 1 (type) + 8 (size of Props) + 8 (size of array)
      for k,v in Obj.OwnProps()
      {
        sz:=RawObjectSize(k,sz) ; name of prop (str)
        sz:=RawObjectSize(v,sz) ; value of prop (any)
      }
      for k,v in Obj
      {
        sz:=RawObjectSize(k,sz) ; index
        sz:=RawObjectSize(v,sz) ; value
      }
    }
    else if (Obj.base=Buffer().base) ; sz = 1 (type) + 8 (size) + (buffer size)
      sz+=9+Obj.size
    else
    {
      MsgBox "Unsupported object type: `"" Type(obj) "`".","ObjDump",0x30
      return 0
    }
  }
  else if IsNumber(obj) ; sz = 1 (type) + (size of data type)
    sz+=IsFloat(Obj)||Obj>4294967295?9:Obj>65535?5:Obj>255?3:Obj>-129?2:Obj>-32769?3:Obj>-2147483649?5:9
  else ; sz = 1 (type) + 8 (size) + (str size)
    sz+=9+StrPut(Obj)
  return sz
}

/*
ASyncCOMPort by Alectric
https://forum.script-coding.com/
Static Method Call(Period:=0,PortNum:=0,BaudRate:=9600,Parity:="N",ByteSize:=8,StopBits:=1,ReadIT:=-1,OnRecieve:=0)
	Creates a new Object.
	If "Period" is presented uses multithread async mode, if not - simple sync mode. See examples below.
	Param "ReadIT" - value of ReadIntervalTimeOut and ReadTotalTimeoutConstant of COM port.
	If "ReadIT" param wasn't set it calculates automaticly.
	Param "OnRecieve" - Func object which will call when any packcage recieve.
	This function must accept at least 1 param - that will be "this" of an object or just use "*" as a param.

For multithread async mode only: -----------------------------------------------------------
Property Package:=[[1,2,3,4]]
	An array of arrays of COM port's buffer data, recieved and sended in order.

Property TimeStamp:=[[A_Now,ms,isSended]]
	An array of time stamps of each package and which package was sendded.

Method Clear()
	Clears both of arrays.

Property Period
	Change period of "Main" routine.

Property COMBusy
	Returns true if can't conect chousen COM Port.

Property GetCOMFail
	Returns last COMFail (see below).

Property GetCOMError
	Returns last COMError (see below).

Property COMOk
	Returns true if connection is Ok.

Property NDR
	Returns true if there is new data to read in "Package" array.

Property NewDataRecieved
	Returns true if there is new data to read and clears "NDR".

Property SlavePID
	PID of child process.

Method AceptSettings(PortNum:=-1,BaudRate:=-1,Parity:="",ByteSize:=-1,StopBits:=-1,ReadIT:=-1)
	Apply defined settings and reconnect the port.

Method SendData(Var,size:=0)
	Send data to port. Var could be an array or buffer or string.

Property Diskonnect
	Set to true to disconnect COM port and stop connect attemtions.

Method Delete()
	To correctly delete an object and free system memory use construction like this: Port:=Port.Delete()

For sync mode only: -------------------------------------------------------------------------------
Method Connect(PortNum:=-1,BaudRate:=-1,Parity:="",ByteSize:=-1,StopBits:=-1,ReadIT:=-1)
	Connect to COM port with params. Or reconnect with new params.
	Param "ReadIT" - see above.
	If params is blank or omitted - uses previously setted value.
	Param "PortNum" must always be presented at first connection attempt.
	Returns port's file handle if success or 0 at fail.
	If failed - use "COMFail" and "ErrorText" props to determine what the problem is.

Method Write(lpBuffer,nNumberOfBytesToWrite)
	Write data to COM port.
	Returns number of written bytes.

Method Read(lpBuffer,nNumberOfBytesToRead)
	Reads data from COM port.
	Returns number of readed bytes.

Method ClearRXBuffer()
	Flush COMport's RX buffer.

Method Close(h:=0)
	Close Handle.
	If call without param - closing object's COM file handle and disconnects COM port.

Property hPort - Returns COM file handle.

Property COMFail
	Inside class number of error. If 0 - all ok.

Property ErrorText
	Text of COMFail error.

Property COMError
	A_LastError of failed DLL.

For any mode: ----------------------------------------------------------------------
Method CalcTimeout(BaudRate,ByteSize:=8)
	Returns approximate ReadIntervalTimeout for chosen BaudRate.

Function CheckCOMPortExist(Port)
	Port could be a string ("COM10") or an integer.
	Returns true if COM port available.

Function SearchCOM(Name:="")
	Search available COM port by name or part of the name and retuns string like "COM10".
	Returns empty string if port not available.
	If call without param - returns list of available COM ports in array of {Port:COMPort,Name:FriendlyName}.

Examples:
;-----------------------------------------------------------------------------------
; Usage in simple sync mode:
  com10:=ASyncCOMPort()			; Create instance of communication
  com10.Connect(10)			; Connect to COM10 with default params

  if !com10.hPort
    msgbox "Error"

  snd:=buffer(1000,0)			; Prepare send buffer
  rcv:=buffer(1000,0)			; Prepare recieve buffer

  numput("Uint64",0x0102030405060708,snd) ; Prepare data to send
  com10.Write(snd,10)			; Do send
  sleep 100				; wait to respond
  sz:=com10.Read(rcv,rcv.size)		; Recieve all available data

  responce:=""				; show recieved data
  loop sz
    responce.=numget(rcv,a_index-1,"UChar") " "
  msgbox responce

;-----------------------------------------------------------------------------------
; Usage in multithread async mode:
;----------------------------------------------;
#SingleInstance off				;
if (A_Args.Length=2)				;
{						;
  ASyncCOMPort()				 ; Always must be the first strings of the script
  return					;
}						;
ComPort1:=ASyncCOMPort(100,,,,,,,OnRecieve)	; "ComPort1" could be any var name
ComPort2:=ASyncCOMPort(100,,,,,,,OnRecieve)	; Any num of instances
;----------------------------------------------;
ComPort2.AceptSettings(10,38400,"E",8,2)
HotKey "Esc",fEsc ; !Do not use simple hotkeys (Esc::), use HotKey command instead! (HotKey "Esc",MyFunc)
OnExit Exit

dots:=""
COMPort:=""
while !COMPort
{
  sleep 1000
  dots.=">"
  if (strlen(dots)>20)
    dots:=""
  COMPort:=SearchCOM("USB")
  if !COMPort
    tooltip "COM port not found`nSearching " dots
}
tooltip
ComPort1.AceptSettings(COMPort)

while !ComPort1.COMOk ; wait for connection
{
  tooltip "Trying to connect to " ComPort1.PortNum " with baud " ComPort1.BaudRate
  sleep 1000
}

HotKey "F1",f
tooltip "Press F1 to send data.`nEsc to exit."

f(*)
{
  snd:=buffer(8,0) ; Prepare buffer to send
  numput("Uint64",0x0A84010000000301,snd) ; prepare data to send (Modbus req for 1 holding register starting from 0)
  ComPort1.SendData(snd) ; Do send
  ComPort2.SendData([1,2,3,4,5,6,7,8,9,10]) ; Do send to another port
}

OnRecieve(Port)
{
  Num:=Port.Package.Length
  sz:=Port.Package[Num].Length		; read last packcage's size
  responce:=""				; show recieved data
  loop sz
    responce.=Port.Package[Num][a_index] " "
  t:=FormatTime(Port.TimeStamp[Num][1],"dd.MM.yyyy hh:mm:ss")
  msgbox Port.PortNum "`nPackcage No" Num "`n" responce "`n" t "." Port.TimeStamp[Num][2]
}

fEsc(*)
{
  exitapp
}
exit(*)
{
  global
  ComPort1:=ComPort1.Delete()	; correctly deleting the objects and clear system memory
  ComPort2:=ComPort2.Delete()
  exitapp
}
;----------------------------------------------------------------------
*/
class ASyncCOMPort
{
  __Delete()
  {
    if this.hPort
      this.Close()
    this.Memory:=""
    if !this.IsMain
      ExitApp
  }
  Delete()
  {
    settimer this.obm,0
    this.obm:=""
  }
  Period
  {
    Set
    {
      settimer this.obm,this._Period:=Value
    }
    get => this._Period
  }
  Baud_List:=[50,75,110,150,300,600,1200,1800
	,2000,2400,3600,4800,7200,9600,14400
	,19200,28800,38400,57600,115200,250000
	,300000,375000,500000,750000,1500000,3000000]
  Parity_List:=["N","E","O","M","S"]
  ByteSize_List:=[5,6,7,8]

  ; Memory offsets
  m:={   Diskonnect	:0	; UChar 1
	,ApplySettings	:1	; UChar 1
	,COMBusy	:2	; UChar 1
	,DataAvailable	:3	; UChar 1
	,SendDataNow	:4	; UChar 1
	,COMFail	:5	; UChar 1
	,COMError	:6	; Int   4
	,PortNum	:10	; Int   4
	,BaudRate	:14	; Int   4
	,Parity		:18	; Str   4	1 char
	,ByteSize	:22	; Int   4
	,StopBits	:26	; Int   4
	,ReadIT		:30	; Int   4
	,SendSize	:34	; Int   4
	,DataPos	:38	; Int   4
	,Packages	:42	; Int   4
	,SndOffset	:100	; Data  900
	,RcvOffset	:1000}	; Data  1047576

  __New(Period:=0,PortNum:=0,BaudRate:=9600,Parity:="N",ByteSize:=8,StopBits:=1,ReadIT:=-1,OnRecieve:=0)
  {
    if !IsInteger(PortNum)
      PortNum:=SearchCOM(PortNum)
    this.PortNum:=PortNum
    this.BaudRate:=BaudRate
    this.Parity:=Parity
    this.ByteSize:=ByteSize
    this.StopBits:=StopBits
    this.ReadIT:=ReadIT
    this.OnRecieve:=OnRecieve
    this.hPort:=0
    this.COMFail:=0
    this.ErrorText:=""
    this.obm:=0
    this.DataSize:=1048576
    this.ReserveMemory:=10240

    this.IsMain:=false
    if (!A_Args.Length and Period)
    { ; Main
      this.IsMain:=true
      this.COMBusy:=false
      this.COMOk:=false
      this.ReadPos:=0
      this.NDR:=false
      this.Package:=[]
      this.TimeStamp:=[]
      this.Data:=Buffer(this.DataSize,0xff)
      loop this.m.RcvOffset
        NumPut("UChar",0,this.Data,a_index-1)
      this.MainPID:=DllCall("GetCurrentProcessId")
      if A_IsCompiled
        run A_ScriptFullPath " " this.MainPID " " this.Data.Ptr,,,&SlavePID
      else
        run "`"" A_AhkPath "`" `"" A_ScriptFullPath "`" " this.MainPID " " this.Data.Ptr,,,&SlavePID
      this.SlavePID:=SlavePID
      if PortNum
        this.AceptSettings(PortNum,BaudRate,Parity,ByteSize,StopBits,ReadIT)
      this.obm:=ObjBindMethod(this,"Main")
      settimer this.obm,Period
    }
    else if (A_Args.Length=2)
    { ; Slave
      if (Period=0)
        Period:=1
      this.MainPID:=A_Args[1]
      this.pData:=A_Args[2]
      this.DataPos:=0
      this.Packages:=0
      obm:=ObjBindMethod(this,"CheckPIDExist")
      settimer obm,2000
      this.MSM:=ClassMemory("Ahk_PID" this.MainPID)
      this.Send_Data:=Buffer(this.m.RcvOffset-this.m.SndOffset)
      for k,v in this.m.OwnProps()
        this.m.%k%:=v+this.pData
      if PortNum
        this.Connect(PortNum,BaudRate,Parity,ByteSize,StopBits,ReadIT)
      this.obm:=ObjBindMethod(this,"Slave")
      settimer this.obm,Period
    }
    this.OldBaudRate:=this.BaudRate
    this._Period:=Period
    return this
  }
  CheckPIDExist()
  {
    if !ProcessExist(this.MainPID)
      this.__Delete()
  }

  Clear()
  {
    this.Package:=[]
    this.TimeStamp:=[]
  }

  AceptSettings(PortNum:=-1,BaudRate:=-1,Parity:="",ByteSize:=-1,StopBits:=-1,ReadIT:=-1)
  {
    if NumGet(this.Data,this.m.ApplySettings,"UChar")
      return
    if (PortNum!=-1)
      this.PortNum:=PortNum
    if IsInteger(this.PortNum)
      this.PortNum:="COM" this.PortNum
    if (BaudRate!=-1)
      this.BaudRate:=BaudRate
    if (Parity!="")
      this.Parity:=Parity
    if (ByteSize!=-1)
      this.ByteSize:=ByteSize
    if (StopBits!=-1)
      this.StopBits:=StopBits
    if !Timeout:=this.CalcTimeout(this.BaudRate,this.ByteSize)
      Timeout:=1
    if (this.ReadIT=-1 or (ReadIT=-1 and this.OldBaudRate!=this.BaudRate))
      this.ReadIT:=Timeout
    this.OldBaudRate:=this.BaudRate
    PortNum:=IsInteger(this.PortNum)?this.PortNum:RegExReplace(this.PortNum,"COM","")
    NumPut("Int",PortNum,this.Data,this.m.PortNum)
    NumPut("Int",this.BaudRate,this.Data,this.m.BaudRate)
    NumPut("Int",Ord(this.Parity),this.Data,this.m.Parity)
    NumPut("Int",this.ByteSize,this.Data,this.m.ByteSize)
    NumPut("Int",this.StopBits,this.Data,this.m.StopBits)
    NumPut("Int",this.ReadIT,this.Data,this.m.ReadIT)
    NumPut("UChar",0,this.Data,this.m.Diskonnect)
    NumPut("UChar",1,this.Data,this.m.ApplySettings)
  }

  SendData(Var,size:=0)
  {
    if (!this.COMOk or NumGet(this.Data,this.m.SendDataNow,"UChar")) ; отправка еще не закончена
      return
    max:=this.m.RcvOffset-this.m.SndOffset
    if (Var.base=[].base)
    {
      size:=size?size:Var.Length
      if (size>max)
      {
        Msgbox("Слишком много данных для отправки. " size " byte.`nМаксимально допустимо " max " byte.")
        return
      }
      loop size
        NumPut("UChar",Var[a_index],this.Data,this.m.SndOffset+a_index-1)
    }
    else if (Var.base=Buffer().base)
    {
      size:=size?size:Var.size
      if (size>max)
      {
        Msgbox("Слишком много данных для отправки. " size " byte.`nМаксимально допустимо " max " byte.")
        return
      }
      loop size
        NumPut("UChar",NumGet(Var,a_index-1,"UChar"),this.Data,this.m.SndOffset+a_index-1)
    }
    else if (!IsObject(Var) and !IsNumber(Var)) ; string
    {
      size:=size?size:StrLen(Var)
      if (size>max)
      {
        Msgbox("Слишком много данных для отправки. " size " byte.`nМаксимально допустимо " max " byte.")
        return
      }
      loop Parse Var
        NumPut("UChar",Ord(A_LoopField),this.Data,this.m.SndOffset+a_index-1)
    }
    NumPut("Int",size,this.Data,this.m.SendSize)
    NumPut("UChar",1,this.Data,this.m.SendDataNow)
    return true
  }

  Diskonnect
  {
    set
    {
      if this.IsMain
        NumPut("UChar",Value,this.Data,this.m.Diskonnect)
      else
        this.Close()
      return
    }
  }
  Main()
  {
    static _TimeStLen:=StrPut(A_Now,"cp0")
    if NumGet(this.Data,this.m.Diskonnect,"UChar")
    {
      this.COMOk:=false
      this.COMBusy:=false
      return
    }
    else if NumGet(this.Data,this.m.COMFail,"UChar")
    {
      NumPut("UChar",0,this.Data,this.m.COMFail)
      this.COMOk:=false
      this.COMBusy:=false
      this.AceptSettings()
    }
    else if NumGet(this.Data,this.m.COMBusy,"UChar")
    {
      NumPut("UChar",0,this.Data,this.m.COMBusy)
      this.COMOk:=false
      this.COMBusy:=true
    }
    else
    {
      this.COMOk:=true
      this.COMBusy:=false
;      ReadPack:=NumGet(this.Data,this.m.Packages,"Int")
      DataValid:=NumGet(this.Data,this.m.RcvOffset+this.ReadPos,"UChar")
      if (DataValid=0xFE)
      {
        this.ReadPos:=0
        return
      }
      else if (DataValid=1)
      {
        NumPut("UChar",0,this.Data,this.m.DataAvailable)
       pStatus:=this.m.RcvOffset+this.ReadPos+1
       pSize:=pStatus+1
        DataFromSlaveSize:=NumGet(this.Data,pSize,"UShort")
       pData:=pSize+2
       pTimeSt:=pData+DataFromSlaveSize
       pTimeMs:=pTimeSt+_TimeStLen
        if (DataFromSlaveSize<0 or DataFromSlaveSize>4096) ;DefaultBReq
        {
          this.ReadPos:=NumGet(this.Data,this.m.DataPos,"Int")
          return
        }
        NumPut("UChar",0XFF,this.Data,this.m.RcvOffset+this.ReadPos)
        NumPut("UShort",0xFFFF,this.Data,pSize)
        if (DataFromSlaveSize>0)
        {
          DataArray:=[]
          loop DataFromSlaveSize
          {
            addr:=pData+a_index-1
            DataArray.Push(NumGet(this.Data,addr,"UChar"))
            NumPut("UChar",0xFF,this.Data,addr)
          }
          TimeSt:=StrGet(this.Data.Ptr+pTimeSt,_TimeStLen,"cp0")
          loop _TimeStLen
            NumPut("UChar",0xFF,this.Data,pTimeSt+a_index-1)
          TimeMs:=NumGet(this.Data,pTimeMs,"UShort")
          NumPut("UShort",0xFFFF,this.Data,pTimeMs)
          Status:=NumGet(this.Data,pStatus,"UChar")
          NumPut("UChar",0xFF,this.Data,pStatus)
          this.ReadPos+=DataFromSlaveSize+_TimeStLen+6
          this.Package.Push(DataArray)
          this.TimeStamp.Push([TimeSt,TimeMs,Status=254?true:false])
          this.NDR:=true
          if (Status!=254 and this.OnRecieve.base=this.Main.base)
            this.OnRecieve()
        }
      }
    }
  }
  NewDataRecieved
  {
    get
    {
      if this.NDR
      {
        this.NDR:=false
        return true
      }
      return false
    }
  }
  GetCOMFail
  {
    get => NumGet(this.Data,this.m.COMFail,"UChar")
  }
  GetCOMError
  {
    get => NumGet(this.Data,this.m.COMError,"Int")
  }

  Slave()
  {
    static _TimeStLen:=StrPut(A_Now,"cp0")
    static StartTime:=0,Frequency:=0,EndTime:=0
    static EmptyPacket:=2,RIT:=0
    static In_Data:=Buffer(8000)
    static SleepTimer:=a_tickcount
	/*
	Array =
	-----------
	DataValid	+0	byte	1
	Status		+1	byte	1
	Size		+2	short	2
	Data byte 0	+4	byte	1
	Data byte 1	+5	byte	1
	Data byte 2	+6	byte	1
	Data byte n	+7	byte	1
	Time Stamp	+n	str	_TimeStLen
	Time ms		+str+n	short	2
	-----------
	Next		+2+str+n

	if Size == 0xFFFFFFFE
	  End
	*/
;tooltip this.PortNum
    if this.MSM.Read(this.m.Diskonnect,"UChar")
    {
;      this.Packages:=0
      this.Close()
    }
    else if this.MSM.Read(this.m.ApplySettings,"UChar")
    {
      this.MSM.write(this.m.ApplySettings,0,"UChar")
;      this.Packages:=0
      this.PortNum:=this.MSM.Read(this.m.PortNum,"Int")
      this.BaudRate:=this.MSM.Read(this.m.BaudRate,"Int")
      this.Parity:=Chr(this.MSM.Read(this.m.Parity,"Int"))
      this.ByteSize:=this.MSM.Read(this.m.ByteSize,"Int")
      this.StopBits:=this.MSM.Read(this.m.StopBits,"Int")
      this.ReadIT:=this.MSM.Read(this.m.ReadIT,"Int")
      ;tooltip this.PortNum "`n" this.BaudRate "`n" this.Parity "`n" this.ByteSize "`n" this.StopBits "`n" this.ReadIT
      this.Connect(this.PortNum
		,this.BaudRate
		,this.Parity
		,this.ByteSize
		,this.StopBits
		,this.ReadIT)
      if !this.hPort
      {
        this.MSM.write(this.m.COMBusy,1,"UChar")
        sleep 500
      }
    }
    if this.COMFail
    {
      this.MSM.write(this.m.COMFail,this.COMFail,"UChar")
      this.MSM.write(this.m.COMError,this.COMError,"Int")
      this.COMFail:=0
    }
    if this.hPort
    {
      if (this.MSM.Read(this.m.SendDataNow,"UChar")=1)
      {
        size:=this.MSM.Read(this.m.SendSize,"Int")
        if size
        {
          Send_Data:=Buffer(size)
          this.MSM.ReadRaw(this.m.SndOffset,Send_Data,size)
         pDataValid:=this.m.RcvOffset+this.DataPos
         pStatus:=pDataValid+1
         pSize:=pStatus+1
         pData:=pSize+2
         pTimeSt:=pData+size
         pTimeMs:=pTimeSt+_TimeStLen
          this.MSM.write(pStatus,254,"uChar")
          this.MSM.write(pSize,size,"uShort")
          this.MSM.WriteRaw(pData,Send_Data,size)
          str:=Buffer(_TimeStLen)
          TimeSt:=a_now
          TimeMs:=a_msec
          StrPut(TimeSt,str,_TimeStLen,"cp0")
          this.MSM.writeRaw(pTimeSt,str,_TimeStLen)
          this.MSM.write(pTimeMs,TimeMs,"UShort")
          this.DataPos+=6+_TimeStLen+size
          this.MSM.write(this.m.DataPos,this.DataPos,"Int")
          this.Packages++
          this.MSM.write(this.m.Packages,this.Packages,"Int")
          this.MSM.write(pDataValid,1,"UChar")
          this.ClearRXBuffer()
          this.Write(Send_Data,size)
        }
        this.MSM.write(this.m.SendDataNow,2,"UChar")
        DllCall("QueryPerformanceCounter","Int64*",&StartTime)
      }
      RCV_Size:=this.Read(In_Data,1)
      if RCV_Size
      {
        Offset:=RCV_Size
        Packet:=false
        EmptyPack:=0
        Status:=0
        DllCall("QueryPerformanceCounter","Int64*",&StartTime)
        loop (1000//this.ReadIT)
        {
          RCV_Size:=this.Read(In_Data.Ptr+Offset,4096)
          DllCall("QueryPerformanceFrequency","Int64*",&Frequency)
          DllCall("QueryPerformanceCounter","Int64*",&EndTime)
          RTimer:=(EndTime-StartTime)/Frequency*1000
          if RCV_Size
          {
            EmptyPack:=0
            Packet:=true
            DllCall("QueryPerformanceCounter","Int64*",&StartTime)
            Offset+=RCV_Size
          }
          else if Packet
            EmptyPack++
          TimeOut:=RTimer>(this.ReadIT*(EmptyPacket+4)) and RTimer>7
          Empty:=(EmptyPack=EmptyPacket)
          if (TimeOut or Empty)
          {
            if TimeOut
              Status:=255
            if Empty
              Status:=EmptyPack
            if TimeOut
            {
              if (++this.ReadIT>255)
                this.ReadIT:=1
              this.MSM.write(this.m.ReadIT,this.ReadIT,"Int")
              RIT:=0
            }
            else
            {
              if (++RIT>10)
              {
                RIT:=0
                if (--this.ReadIT<1)
                  this.ReadIT:=1
                this.MSM.write(this.m.ReadIT,this.ReadIT,"Int")
              }
            }
            this.MSM.write(this.m.SendDataNow,0,"UChar")
            break
          }
        }
        RCV_Size:=Offset
        str:=Buffer(_TimeStLen)
        TimeSt:=a_now
        TimeMs:=a_msec
        StrPut(TimeSt,str,_TimeStLen,"cp0")
       pDataValid:=this.m.RcvOffset+this.DataPos
       pStatus:=pDataValid+1
       pSize:=pStatus+1
       pData:=pSize+2
       pTimeSt:=pData+RCV_Size
       pTimeMs:=pTimeSt+_TimeStLen
        this.MSM.write(pStatus,Status,"UChar")
        this.MSM.write(pSize,RCV_Size,"UShort")
        this.MSM.WriteRaw(pData,In_Data,RCV_Size)
        this.MSM.writeRaw(pTimeSt,str,_TimeStLen)
        this.MSM.write(pTimeMs,TimeMs,"UShort")
        this.DataPos+=6+_TimeStLen+RCV_Size
        this.MSM.write(this.m.DataPos,this.DataPos,"Int")
        this.Packages++
        this.MSM.write(this.m.Packages,this.Packages,"Int")
        this.MSM.write(pDataValid,1,"UChar")
        RCV_Size:=0
        SleepTimer:=a_tickcount
      }
      else
      {
        DllCall("QueryPerformanceFrequency","Int64*",&Frequency)
        DllCall("QueryPerformanceCounter","Int64*",&EndTime)
        RTimer:=(EndTime-StartTime)/Frequency*1000
        if (RTimer>100)
        {
          this.MSM.write(this.m.SendDataNow,0,"UChar")
          DllCall("QueryPerformanceCounter","Int64*",&StartTime)
        }
      }
      if (a_tickcount-SleepTimer>30000)
        sleep 10

      if (this.DataPos>this.DataSize-(this.m.RcvOffset-this.pData)-this.ReserveMemory)
      {
       pDataValid:=this.m.RcvOffset+this.DataPos
        this.MSM.write(pDataValid,0xFE,"UChar")
        this.DataPos:=0
        this.MSM.write(this.m.DataPos,this.DataPos,"Int")
        this.Packages:=0
        this.MSM.write(this.m.Packages,this.Packages,"Int")
      }
    }
    else
      sleep 100
  }

  Write(lpBuffer,nNumberOfBytesToWrite)
  {
    lpNumberOfBytesWritten:=0
    Result:=DllCall("WriteFile"
         ,"Ptr",this.hPort
         ,"Ptr",IsInteger(lpBuffer)?lpBuffer:lpBuffer.Ptr
         ,"UInt",nNumberOfBytesToWrite
         ,"UPtr*",&lpNumberOfBytesWritten
         ,"Ptr",0) ; lpOverlapped
    If !Result
    {
      this.COMFail:=8
      this.ErrorText:=
	(
	"There is a problem with Serial Port communication.
	Failed Dll - WriteFile.
	LastError=" A_LastError
        )
      this.COMError:=A_LastError
      this.Close()
      return 0
    }
    return lpNumberOfBytesWritten
  }

  Read(lpBuffer,nNumberOfBytesToRead)
  {
    lpNumberOfBytesReceived:=0
    Result:=DllCall("ReadFile"
         ,"Ptr",this.hPort
         ,"Ptr",IsInteger(lpBuffer)?lpBuffer:lpBuffer.Ptr
         ,"UInt",nNumberOfBytesToRead
         ,"UPtr*",&lpNumberOfBytesReceived
         ,"Ptr",0) ; lpOverlapped
    If !Result
    {
      this.COMFail:=9
      this.ErrorText:=
	(
	"There is a problem with Serial Port communication.
	Failed Dll - ReadFile.
	LastError=" A_LastError
        )
      this.COMError:=A_LastError
      this.Close()
      return 0
    }
    return lpNumberOfBytesReceived
  }

  ClearRXBuffer()
  {
    Success:=DllCall("PurgeComm"
         ,"Ptr",this.hPort
         ,"Int",0x8) ; dwFlag PURGE_RXCLEAR=0x08; PURGE_TXCLEAR=0x04
    return Success
  }

  ClearCommError()
  {
    return DllCall("ClearCommError","Ptr",this.hPort)
  }

  CalcTimeout(BaudRate,ByteSize:=8)
  {
    return Floor(((ByteSize+4)/BaudRate)*1000)
  }

  Connect(PortNum:=-1,BaudRate:=-1,Parity:="",ByteSize:=-1,StopBits:=-1,ReadIT:=-1)
  {
    if (PortNum!=-1)
      this.PortNum:=PortNum
    if IsInteger(this.PortNum)
      this.PortNum:="COM" this.PortNum
    if (BaudRate!=-1)
      this.BaudRate:=BaudRate
    if (Parity!="")
      this.Parity:=Parity
    if (ByteSize!=-1)
      this.ByteSize:=ByteSize
    if (StopBits!=-1)
      this.StopBits:=StopBits

    if (ReadIT!=-1)
      this.ReadIT:=ReadIT
    if !Timeout:=this.CalcTimeout(this.BaudRate,this.ByteSize)
      Timeout:=1
    if (this.ReadIT=-1 or (ReadIT=-1 and this.OldBaudRate!=this.BaudRate))
      this.ReadIT:=Timeout
    this.OldBaudRate:=this.BaudRate

    if !CheckCOMPortExist(this.PortNum)
    {
      this.COMFail:=1
      this.ErrorText:="Port " this.PortNum " not exist."
      return 0
    }
    this.COMFail:=0
    this.ErrorText:=""
    if this.IsMain
      return true
    if this.hPort
      this.Close()
    lpDef:=	 "baud=" this.BaudRate .
		" parity=" this.Parity .
		" data=" this.ByteSize .
		" stop=" this.StopBits .
		" to=off xon=off odsr=off octs=off dtr=Off rts=off idsr=off"
    lpDCB:=Buffer(28,0)
    if !DllCall("BuildCommDCB","Str",lpDef,"Ptr",lpDCB.Ptr)
    {
      this.COMFail:=2
      this.ErrorText:=
	(
	"There is a problem with Serial Port communication.
	Failed Dll - BuildCommDCB.
	LastError=" A_LastError
        )
      this.COMError:=A_LastError
      return 0
    }
    hFile:=DllCall("CreateFile"
       ,"Str","\\.\" this.PortNum	;lpFileName
       ,"UInt",0xC0000000		;dwDesiredAccess GENERIC_READ=0x80000000 || GENERIC_WRITE=0x40000000
       ,"UInt",3			;dwShareMode FILE_SHARE_READ=0x01 || FILE_SHARE_WRITE=0x02
       ,"UInt",0			;lpSecurityAttributes
       ,"UInt",3			;dwCreationDisposition CREATE_NEW=0x01 || CREATE_ALWAYS=0x02
       ,"UInt",0			;dwFlagsAndAttributes
       ,"Ptr",0				;hTemplateFile
       ,"Ptr")
    if !hFile
    {
      this.COMFail:=3
      this.ErrorText:=
	(
	"There is a problem with Serial Port communication.
	Failed Dll - CreateFile.
	LastError=" A_LastError
        )
      this.COMError:=A_LastError
      return 0
    }
    if !DllCall("SetCommState","Ptr",hFile,"Ptr",lpDCB.Ptr)
    {
      this.COMFail:=4
      this.ErrorText:=
	(
	"There is a problem with Serial Port communication.
	Failed Dll - SetCommState.
	LastError=" A_LastError
        )
      this.COMError:=A_LastError
      this.Close(hFile)
      return 0
    }
    lpCommTimeouts:=Buffer(20,0) ; 5 * sizeof(DWORD)
    NumPut("UInt",this.ReadIT	,lpCommTimeouts, 0) ;ReadIntervalTimeout -  ms, max Interval betwen characters
    NumPut("UInt",0		,lpCommTimeouts, 4) ;ReadTotalTimeoutMultiplier - ms * reqested number of bytes
    NumPut("UInt",this.ReadIT	,lpCommTimeouts, 8) ;ReadTotalTimeoutConstant - ms
    NumPut("UInt",100		,lpCommTimeouts,12) ;WriteTotalTimeoutMultiplier - ms * sended number of bytes
    NumPut("UInt",10000		,lpCommTimeouts,16) ;WriteTotalTimeoutConstant - ms
    if !DllCall("SetCommTimeouts","Ptr",hFile,"Ptr",lpCommTimeouts.Ptr)
    {
      this.COMFail:=5
      this.ErrorText:=
	(
	"There is a problem with Serial Port communication.
	Failed Dll - SetCommTimeouts.
	LastError=" A_LastError
        )
      this.COMError:=A_LastError
      this.Close(hFile)
      return 0
    }
    return this.hPort:=hFile
  }

  Close(h:=0)
  {
    DllCall("CloseHandle","Ptr",(h?h:this.hPort))
    this.hPort:=0
  }

  WaitCommEvent(dwEvtMask:=0x3ff)
  {
  /*
  Events:
  EV_BREAK:=0x0040 ;A break was detected on input.
  EV_CTS:=0x0008 ;The CTS (clear-to-send) signal changed state.
  EV_DSR:=0x0010 ;The DSR (data-set-ready) signal changed state.
  EV_ERR:=0x0080 ;A line-status error occurred. Line-status errors are CE_FRAME, CE_OVERRUN, and CE_RXPARITY.
  EV_RING:=0x0100 ;A ring indicator was detected.
  EV_RLSD:=0x0020 ;The RLSD (receive-line-signal-detect) signal changed state.
  EV_RXCHAR:=0x0001 ;A character was received and placed in the input buffer.
  EV_RXFLAG:=0x0002 ;The event character was received and placed in the input buffer. The event character is specified in the device's DCB structure, which is applied to a serial port by using the SetCommState function.
  EV_TXEMPTY:=0x0004 ;The last character in the output buffer was sent.
  */
    MaskSet:=DllCall("SetCommMask"
         ,"Ptr",this.hPort
         ,"int",dwEvtMask)
    if !MaskSet
    {
      this.COMFail:=6
      this.ErrorText:=
	(
	"There is a problem with Serial Port communication.
	Failed Dll - SetCommMask.
	LastError=" A_LastError
        )
      this.COMError:=A_LastError
      this.Close()
      return 0
    }
    lpEvtMask:=Buffer(4,0)
    Success:=DllCall("WaitCommEvent"
         ,"Ptr",this.hPort
         ,"Ptr",lpEvtMask.Ptr
         ,"Ptr",0) ; lpOverlapped
    if !Success
    {
      this.COMFail:=7
      this.ErrorText:=
	(
	"There is a problem with Serial Port communication.
	Failed Dll - WaitCommEvent.
	LastError=" A_LastError
        )
      this.COMError:=A_LastError
      this.Close()
      return 0
    }
    return 1
  }
}

CheckCOMPortExist(Port)
{
  if isinteger(Port)
    Port:="COM" Port
  List:=SearchCOM()
  loop List.Length
  {
    o:=List[a_index]
    if (o.Port=Port)
      return true
  }
}
SearchCOM(Name:="")
{
  if !Name
    Out:=[]
  Loop Reg "HKLM\HARDWARE\DEVICEMAP\SERIALCOMM\"
  {
    COMPort:=RegRead()
    FriendlyName:=""
    Loop Reg "HKLM\SYSTEM\CurrentControlSet\Enum","KVR"
    {
      if (A_LoopRegName="PortName")
      {
        Outputvar:=RegRead()
        if (Outputvar=COMPort)
        {
          FriendlyName:=RegRead(RegExReplace(A_LoopRegKey, "(.*)\\Device Parameters", "$1"),"FriendlyName","")
          if (Name and InStr(FriendlyName,Name))
            return COMPort
        }
      }
    }
    if (FriendlyName="")
      FriendlyName:=A_LoopRegName
    if !Name
      Out.Push({Port:COMPort,Name:FriendlyName})
    else if (InStr(A_LoopRegName,Name))
      return COMPort
  }
  if !Name
    return Out
  return ""
}


class ClassMemory
{
    ; List of useful accessible values. Some of these inherited values (the non objects) are set when the new operator is used.

    static aTypeSize := {UChar:	1,Char:		1
                    ,UShort:	2,Short:	2
                    ,UInt:	4,Int:		4
                    ,UFloat:	4,Float:	4
                    ,Int64:	8,Double:	8}
    static aRights := {PROCESS_ALL_ACCESS: 0x001F0FFF
			,PROCESS_CREATE_PROCESS: 0x0080
			,PROCESS_CREATE_THREAD: 0x0002
			,PROCESS_DUP_HANDLE: 0x0040
			,PROCESS_QUERY_INFORMATION: 0x0400
			,PROCESS_QUERY_LIMITED_INFORMATION: 0x1000
			,PROCESS_SET_INFORMATION: 0x0200
			,PROCESS_SET_QUOTA: 0x0100
			,PROCESS_SUSPEND_RESUME: 0x0800
			,PROCESS_TERMINATE: 0x0001
			,PROCESS_VM_OPERATION: 0x0008
			,PROCESS_VM_READ: 0x0010
			,PROCESS_VM_WRITE: 0x0020
			,SYNCHRONIZE: 0x00100000}

    ; Method:    __new(program, dwDesiredAccess := "", byRef handle := "", windowMatchMode := 3)
    ; Example:  derivedObject := new _ClassMemory("ahk_exe calc.exe")
    ;           This is the first method which should be called when trying to access a program's memory.
    ;           If the process is successfully opened, an object is returned which can be used to read that processes memory space.
    ;           [derivedObject].hProcess stores the opened handle.
    ;           If the target process closes and re-opens, simply free the derived object and use the new operator again to open a new handle.
    ; Parameters:
    ;   program             The program to be opened. This can be any AHK windowTitle identifier, such as
    ;                       ahk_exe, ahk_class, ahk_pid, or simply the window title. e.g. "ahk_exe calc.exe" or "Calculator".
    ;                       It's safer not to use the window title, as some things can have the same window title e.g. an open folder called "Starcraft II"
    ;                       would have the same window title as the game itself.
    ;                       *'DetectHiddenWindows, On' is required for hidden windows*
    ;   dwDesiredAccess     The access rights requested when opening the process.
    ;                       If this parameter is null the process will be opened with the following rights
    ;                       PROCESS_QUERY_INFORMATION, PROCESS_VM_OPERATION, PROCESS_VM_READ, PROCESS_VM_WRITE, & SYNCHRONIZE
    ;                       This access level is sufficient to allow all of the methods in this class to work.
    ;                       Specific process access rights are listed here http://msdn.microsoft.com/en-us/library/windows/desktop/ms684880(v=vs.85).aspx
    ;   handle (Output)     Optional variable in which a copy of the opened processes handle will be stored.
    ;                       Values:
    ;                           Null    OpenProcess failed. The script may need to be run with admin rights admin,
    ;                                   and/or with the use of _ClassMemory.setSeDebugPrivilege(). Consult A_LastError for more information.
    ;                           0       The program isn't running (not found) or you passed an incorrect program identifier parameter.
    ;                                   In some cases _ClassMemory.setSeDebugPrivilege() may be required.
    ;                           Positive Integer    A handle to the process. (Success)
    ;   windowMatchMode -   Determines the matching mode used when finding the program (windowTitle).
    ;                       The default value is 3 i.e. an exact match. Refer to AHK's setTitleMathMode for more information.
    ; Return Values:
    ;   Object  On success an object is returned which can be used to read the processes memory.
    ;   Null    Failure. A_LastError and the optional handle parameter can be consulted for more information.


    __new(program, dwDesiredAccess := "", handle := "", windowMatchMode := 3)
    {
        DHW:=A_DetectHiddenWindows
        DetectHiddenWindows true
        if this.PID := handle := this.findPID(program, windowMatchMode) ; set handle to 0 if program not found
        {
            ; This default access level is sufficient to read and write memory addresses, and to perform pattern scans.
            ; if the program is run using admin privileges, then this script will also need admin privileges
            if !IsInteger(dwDesiredAccess)
                dwDesiredAccess := ClassMemory.aRights.PROCESS_QUERY_INFORMATION | ClassMemory.aRights.PROCESS_VM_OPERATION | ClassMemory.aRights.PROCESS_VM_READ | ClassMemory.aRights.PROCESS_VM_WRITE
            dwDesiredAccess |= ClassMemory.aRights.SYNCHRONIZE ; add SYNCHRONIZE to all handles to allow isHandleValid() to work

            if this.hProcess := handle := this.OpenProcess(this.PID, dwDesiredAccess) ; NULL/Blank if failed to open process for some reason
            {
                this.pNumberOfBytesRead := DllCall("GlobalAlloc", "UInt", 0x0040, "Ptr", A_PtrSize, "Ptr") ; 0x0040 initialise to 0
                this.pNumberOfBytesWritten := DllCall("GlobalAlloc", "UInt", 0x0040, "Ptr", A_PtrSize, "Ptr") ; initialise to 0

                this.readStringLastError := False
                this.currentProgram := program
                if this.isTarget64bit := this.isTargetProcess64Bit(this.PID, this.hProcess, dwDesiredAccess)
                    this.ptrType := "Int64"
                else this.ptrType := "UInt" ; If false or Null (fails) assume 32bit

                ; if script is 64 bit, getModuleBaseAddress() should always work
                ; if target app is truly 32 bit, then getModuleBaseAddress()
                ; will work when script is 32 bit
                if (A_PtrSize != 4 || !this.isTarget64bit)
                    this.BaseAddress := this.getModuleBaseAddress()

                ; If the above failed or wasn't called, fall back to alternate method
                if this.BaseAddress < 0 || !this.BaseAddress
                    this.BaseAddress := this.getProcessBaseAddress(program, windowMatchMode)
                DetectHiddenWindows DHW
                return this
            }
        }
        DetectHiddenWindows DHW
        return
    }

    __delete()
    {
        this.closeHandle(this.hProcess)
        if this.pNumberOfBytesRead
            DllCall("GlobalFree", "Ptr", this.pNumberOfBytesRead)
        if this.pNumberOfBytesWritten
            DllCall("GlobalFree", "Ptr", this.pNumberOfBytesWritten)
        return
    }

    version()
    {
        return 9999.9999
    }

    findPID(program, windowMatchMode := "3")
    {
        ; If user passes an AHK_PID, don't bother searching. There are cases where searching windows for PIDs
        ; wont work - console apps
        if RegExMatch(program, "i)\s*AHK_PID\s+(0x[[:xdigit:]]+|\d+)", &pid)
            return pid[1]
        if windowMatchMode
        {
            ; This is a string and will not contain the 0x prefix
            mode := A_TitleMatchMode
            ; remove hex prefix as SetTitleMatchMode will throw a run time error. This will occur if integer mode is set to hex and user passed an int (unquoted)
            windowMatchMode:=StrReplace(windowMatchMode,"0x")
;            StringReplace, windowMatchMode, windowMatchMode, 0x
            SetTitleMatchMode windowMatchMode
        }
        pid:=WinGetPid(program)
        if windowMatchMode
            SetTitleMatchMode mode    ; In case executed in autoexec

        ; If use 'ahk_exe test.exe' and winget fails (which can happen when setSeDebugPrivilege is required),
        ; try using the process command. When it fails due to setSeDebugPrivilege, setSeDebugPrivilege will still be required to openProcess
        ; This should also work for apps without windows.
        if (!pid && RegExMatch(program, "i)\bAHK_EXE\b\s*(.*)", &fileNm))
        {
            ; remove any trailing AHK_XXX arguments
            filename := RegExReplace(fileNm[1], "i)\bahk_(class|id|pid|group)\b.*", "")
            filename := trim(filename)    ; extra spaces will make process command fail
            ; AHK_EXE can be the full path, so just get filename
            SplitPath fileName , &fileName
            if (fileName) ; if filename blank, scripts own pid is returned
                pid := ProcessExist(fileName)
        }

        return pid ? pid : 0 ; PID is null on fail, return 0
    }

    ; Method:   isHandleValid()
    ;           This method provides a means to check if the internal process handle is still valid
    ;           or in other words, the specific target application instance (which you have been reading from)
    ;           has closed or restarted.
    ;           For example, if the target application closes or restarts the handle will become invalid
    ;           and subsequent calls to this method will return false.
    ;
    ; Return Values:
    ;   True    The handle is valid.
    ;   False   The handle is not valid.
    ;
    ; Notes:
    ;   This operation requires a handle with SYNCHRONIZE access rights.
    ;   All handles, even user specified ones are opened with the SYNCHRONIZE access right.

    isHandleValid()
    {
        return 0x102 = DllCall("WaitForSingleObject", "Ptr", this.hProcess, "UInt", 0)
        ; WaitForSingleObject return values
        ; -1 if called with null hProcess (sets lastError to 6 - invalid handle)
        ; 258 / 0x102 WAIT_TIMEOUT - if handle is valid (process still running)
        ; 0  WAIT_OBJECT_0 - if process has terminated
    }

    ; Method:   openProcess(PID, dwDesiredAccess)
    ;           ***Note:    This is an internal method which shouldn't be called directly unless you absolutely know what you are doing.
    ;                       This is because the new operator, in addition to calling this method also sets other values
    ;                       which are required for the other methods to work correctly.
    ; Parameters:
    ;   PID                 The Process ID of the target process.
    ;   dwDesiredAccess     The access rights requested when opening the process.
    ;                       Specific process access rights are listed here http://msdn.microsoft.com/en-us/library/windows/desktop/ms684880(v=vs.85).aspx
    ; Return Values:
    ;   Null/blank          OpenProcess failed. If the target process has admin rights, then the script also needs to be ran as admin.
    ;                       _ClassMemory.setSeDebugPrivilege() may also be required.
    ;   Positive integer    A handle to the process.

    openProcess(PID, dwDesiredAccess)
    {
        r := DllCall("OpenProcess", "UInt", dwDesiredAccess, "Int", False, "UInt", PID, "Ptr")
        ; if it fails with 0x5 ERROR_ACCESS_DENIED, try enabling privilege ... lots of users never try this.
        ; there may be other errors which also require DebugPrivilege....
        if (!r && A_LastError = 5)
        {
            this.setSeDebugPrivilege(true) ; no harm in enabling it if it is already enabled by user
            if (r2 := DllCall("OpenProcess", "UInt", dwDesiredAccess, "Int", False, "UInt", PID, "Ptr"))
                return r2
            DllCall("SetLastError", "UInt", 5) ; restore original error if it doesnt work
        }
        ; If fails with 0x5 ERROR_ACCESS_DENIED (when setSeDebugPrivilege() is req.), the func. returns 0 rather than null!! Set it to null.
        ; If fails for another reason, then it is null.
        return r ? r : 0
    }

    ; Method:   closeHandle(hProcess)
    ;           Note:   This is an internal method which is automatically called when the script exits or the derived object is freed/destroyed.
    ;                   There is no need to call this method directly. If you wish to close the handle simply free the derived object.
    ;                   i.e. derivedObject := [] ; or derivedObject := ""
    ; Parameters:
    ;   hProcess        The handle to the process, as returned by openProcess().
    ; Return Values:
    ;   Non-Zero        Success
    ;   0               Failure

    closeHandle(hProcess)
    {
        return DllCall("CloseHandle", "Ptr", hProcess)
    }

    ; Methods:      numberOfBytesRead() / numberOfBytesWritten()
    ;               Returns the number of bytes read or written by the last ReadProcessMemory or WriteProcessMemory operation.
    ;
    ; Return Values:
    ;   zero or positive value      Number of bytes read/written
    ;   -1                          Failure. Shouldn't occur

    numberOfBytesRead()
    {
        return !this.pNumberOfBytesRead ? -1 : NumGet(this.pNumberOfBytesRead+0, "Ptr")
    }
    numberOfBytesWritten()
    {
        return !this.pNumberOfBytesWritten ? -1 : NumGet(this.pNumberOfBytesWritten+0, "Ptr")
    }


    ; Method:   read(address, type := "UInt", aOffsets*)
    ;           Reads various integer type values
    ; Parameters:
    ;       address -   The memory address of the value or if using the offset parameter,
    ;                   the base address of the pointer.
    ;       type    -   The integer type.
    ;                   Valid types are UChar, Char, UShort, Short, UInt, Int, Float, Int64 and Double.
    ;                   Note: Types must not contain spaces i.e. " UInt" or "UInt " will not work.
    ;                   When an invalid type is passed the method returns NULL and sets ErrorLevel to -2
    ;       aOffsets* - A variadic list of offsets. When using offsets the address parameter should equal the base address of the pointer.
    ;                   The address (base address) and offsets should point to the memory address which holds the integer.
    ; Return Values:
    ;       integer -   Indicates success.
    ;       Null    -   Indicates failure. Check ErrorLevel and A_LastError for more information.
    ;       Note:       Since the returned integer value may be 0, to check for success/failure compare the result
    ;                   against null i.e. if (result = "") then an error has occurred.
    ;                   When reading doubles, adjusting "SetFormat, float, totalWidth.DecimalPlaces"
    ;                   may be required depending on your requirements.

    read(address, type := "UInt")
    {
        ; If invalid type RPM() returns success (as bytes to read resolves to null in dllCall())
        ; so set errorlevel to invalid parameter for DLLCall() i.e. -2
        if !ClassMemory.aTypeSize.%type%
            return 0
        result:=0
        if DllCall("ReadProcessMemory", "Ptr", this.hProcess, "Ptr", address, type "*", &result, "Ptr", ClassMemory.aTypeSize.%type%, "Ptr", this.pNumberOfBytesRead)
            return result
        return
    }

    ; Method:   readRaw(address, byRef buffer, bytes := 4, aOffsets*)
    ;           Reads an area of the processes memory and stores it in the buffer variable
    ; Parameters:
    ;       address  -  The memory address of the area to read or if using the offsets parameter
    ;                   the base address of the pointer which points to the memory region.
    ;       buffer   -  The unquoted variable name for the buffer. This variable will receive the contents from the address space.
    ;                   This method calls varsetCapcity() to ensure the variable has an adequate size to perform the operation.
    ;                   If the variable already has a larger capacity (from a previous call to varsetcapcity()), then it will not be shrunk.
    ;                   Therefore it is the callers responsibility to ensure that any subsequent actions performed on the buffer variable
    ;                   do not exceed the bytes which have been read - as these remaining bytes could contain anything.
    ;       bytes   -   The number of bytes to be read.
    ;       aOffsets* - A variadic list of offsets. When using offsets the address parameter should equal the base address of the pointer.
    ;                   The address (base address) and offsets should point to the memory address which is to be read
    ; Return Values:
    ;       Non Zero -   Indicates success.
    ;       Zero     -   Indicates failure. Check errorLevel and A_LastError for more information
    ;
    ; Notes:            The contents of the buffer may then be retrieved using AHK's NumGet() and StrGet() functions.
    ;                   This method offers significant (~30% and up) performance boost when reading large areas of memory.
    ;                   As calling ReadProcessMemory for four bytes takes a similar amount of time as it does for 1,000 bytes.

    readRaw(address, buffer, bytes := 4)
    {
;        Data.__new(bytes)
        return DllCall("ReadProcessMemory", "Ptr", this.hProcess, "Ptr", address, "Ptr",IsInteger(buffer)?buffer:buffer.ptr, "Ptr", bytes, "Ptr", this.pNumberOfBytesRead)
    }

    ; Method:   write(address, value, type := "Uint", aOffsets*)
    ;           Writes various integer type values to the process.
    ; Parameters:
    ;       address -   The memory address to which data will be written or if using the offset parameter,
    ;                   the base address of the pointer.
    ;       type    -   The integer type.
    ;                   Valid types are UChar, Char, UShort, Short, UInt, Int, Float, Int64 and Double.
    ;                   Note: Types must not contain spaces i.e. " UInt" or "UInt " will not work.
    ;                   When an invalid type is passed the method returns NULL and sets ErrorLevel to -2
    ;       aOffsets* - A variadic list of offsets. When using offsets the address parameter should equal the base address of the pointer.
    ;                   The address (base address) and offsets should point to the memory address which is to be written to.
    ; Return Values:
    ;       Non Zero -  Indicates success.
    ;       Zero     -  Indicates failure. Check errorLevel and A_LastError for more information
    ;       Null    -   An invalid type was passed. Errorlevel is set to -2

    write(address, value, type := "Uint")
    {
        if !ClassMemory.aTypeSize.%type%
            return false
        return DllCall("WriteProcessMemory", "Ptr", this.hProcess, "Ptr", address, type "*", &value, "Ptr", ClassMemory.aTypeSize.%type%, "Ptr", this.pNumberOfBytesWritten)
    }

    ; Method:   writeRaw(address, pBuffer, sizeBytes, aOffsets*)
    ;           Writes a buffer to the process.
    ; Parameters:
    ;   address -       The memory address to which the contents of the buffer will be written
    ;                   or if using the offset parameter, the base address of the pointer.
    ;   pBuffer -       A pointer to the buffer which is to be written.
    ;                   This does not necessarily have to be the beginning of the buffer itself e.g. pBuffer := &buffer + offset
    ;   sizeBytes -     The number of bytes which are to be written from the buffer.
    ;   aOffsets* -     A variadic list of offsets. When using offsets the address parameter should equal the base address of the pointer.
    ;                   The address (base address) and offsets should point to the memory address which is to be written to.
    ; Return Values:
    ;       Non Zero -  Indicates success.
    ;       Zero     -  Indicates failure. Check errorLevel and A_LastError for more information

    writeRaw(address, Buffer, sizeBytes)
    {
        return DllCall("WriteProcessMemory", "Ptr", this.hProcess, "Ptr", address, "Ptr",IsInteger(Buffer)?Buffer:Buffer.Ptr, "Ptr", sizeBytes, "Ptr", this.pNumberOfBytesWritten)
    }

    ; Interesting note:
    ; Although handles are 64-bit pointers, only the less significant 32 bits are employed in them for the purpose
    ; of better compatibility (for example, to enable 32-bit and 64-bit processes interact with each other)
    ; Here are examples of such types: HANDLE, HWND, HMENU, HPALETTE, HBITMAP, etc.
    ; http://www.viva64.com/en/k/0005/



    ; Method:   getProcessBaseAddress(WindowTitle, windowMatchMode := 3)
    ;           Returns the base address of a process. In most cases this will provide the same result as calling getModuleBaseAddress() (when passing
    ;           a null value as the module parameter), however getProcessBaseAddress() will usually work regardless of the bitness
    ;           of both the AHK exe and the target process.
    ;           *This method relies on the target process having a window and will not work for console apps*
    ;           *'DetectHiddenWindows, On' is required for hidden windows*
    ;           ***If this returns an incorrect value, try using (the MORE RELIABLE) getModuleBaseAddress() instead.***
    ; Parameters:
    ;   windowTitle         This can be any AHK windowTitle identifier, such as
    ;                       ahk_exe, ahk_class, ahk_pid, or simply the window title. e.g. "ahk_exe calc.exe" or "Calculator".
    ;                       It's safer not to use the window title, as some things can have the same window title e.g. an open folder called "Starcraft II"
    ;                       would have the same window title as the game itself.
    ;   windowMatchMode     Determines the matching mode used when finding the program's window (windowTitle).
    ;                       The default value is 3 i.e. an exact match. The current matchmode will be used if the parameter is null or 0.
    ;                       Refer to AHK's setTitleMathMode for more information.
    ; Return Values:
    ;   Positive integer    The base address of the process (success).
    ;   Null                The process's window couldn't be found.
    ;   0                   The GetWindowLong or GetWindowLongPtr call failed. Try getModuleBaseAddress() instead.


    getProcessBaseAddress(windowTitle, windowMatchMode := "3")
    {
        mode:=0
        if (windowMatchMode && A_TitleMatchMode != windowMatchMode)
        {
            mode := A_TitleMatchMode ; This is a string and will not contain the 0x prefix
            windowMatchMode:=StrReplace(windowMatchMode,"0x")
;            StringReplace windowMatchMode, windowMatchMode, 0x ; remove hex prefix as SetTitleMatchMode will throw a run time error. This will occur if integer mode is set to hex and matchmode param is passed as an number not a string.
            SetTitleMatchMode windowMatchMode    ;mode 3 is an exact match
        }
        hWnd:=WinGetID(WindowTitle)
        if mode
            SetTitleMatchMode mode    ; In case executed in autoexec
        if !hWnd
            return 0 ; return blank failed to find window
      ; GetWindowLong returns a Long (Int) and GetWindowLongPtr return a Long_Ptr
        return DllCall(A_PtrSize = 4     ; If DLL call fails, returned value will = 0
            ? "GetWindowLong"
            : "GetWindowLongPtr"
            , "Ptr", hWnd, "Int", -6, A_Is64bitOS ? "Int64" : "UInt")
            ; For the returned value when the OS is 64 bit use Int64 to prevent negative overflow when AHK is 32 bit and target process is 64bit
            ; however if the OS is 32 bit, must use UInt, otherwise the number will be huge (however it will still work as the lower 4 bytes are correct)
            ; Note - it's the OS bitness which matters here, not the scripts/AHKs
    }

    ; http://winprogger.com/getmodulefilenameex-enumprocessmodulesex-failures-in-wow64/
    ; http://stackoverflow.com/questions/3801517/how-to-enum-modules-in-a-64bit-process-from-a-32bit-wow-process

    ; Method:            getModuleBaseAddress(module := "", byRef aModuleInfo := "")
    ; Parameters:
    ;   moduleName -    The file name of the module/dll to find e.g. "calc.exe", "GDI32.dll", "Bass.dll" etc
    ;                   If no module (null) is specified, the address of the base module - main()/process will be returned
    ;                   e.g. for calc.exe the following two method calls are equivalent getModuleBaseAddress() and getModuleBaseAddress("calc.exe")
    ;   aModuleInfo -   (Optional) A module Info object is returned in this variable. If method fails this variable is made blank.
    ;                   This object contains the keys: name, fileName, lpBaseOfDll, SizeOfImage, and EntryPoint
    ; Return Values:
    ;   Positive integer - The module's base/load address (success).
    ;   -1 - Module not found
    ;   -3 - EnumProcessModulesEx failed
    ;   -4 - The AHK script is 32 bit and you are trying to access the modules of a 64 bit target process. Or the target process has been closed.
    ; Notes:    A 64 bit AHK can enumerate the modules of a target 64 or 32 bit process.
    ;           A 32 bit AHK can only enumerate the modules of a 32 bit process
    ;           This method requires PROCESS_QUERY_INFORMATION + PROCESS_VM_READ access rights. These are included by default with this class.

    getModuleBaseAddress()
    {
        moduleName := this.GetModuleFileNameEx(0, True) ; main executable module of the process - get just fileName no path
        aModules:=map()
        if (r := this.getModules(&aModules, True) < 0)
            return r ; -4, -3
        return aModules.has(moduleName) ? (aModules[moduleName].lpBaseOfDll) : -1
        ; no longer returns -5 for failed to get module info
    }

    ; SeDebugPrivileges is required to read/write memory in some programs.
    ; This only needs to be called once when the script starts,
    ; regardless of the number of programs being read (or if the target programs restart)
    ; Call this before attempting to call any other methods in this class
    ; i.e. call _ClassMemory.setSeDebugPrivilege() at the very start of the script.

    setSeDebugPrivilege(enable := True)
    {
        h := DllCall("OpenProcess", "UInt", 0x0400, "Int", false, "UInt", DllCall("GetCurrentProcessId"), "Ptr")
        ; Open an adjustable access token with this process (TOKEN_ADJUST_PRIVILEGES = 32)
        t:=0
        DllCall("Advapi32.dll\OpenProcessToken", "Ptr", h, "UInt", 32, "PtrP", &t)
        ti:=Buffer(16,0)
;        VarSetCapacity(ti, 16, 0)  ; structure of privileges
        NumPut("UInt",1, ti, 0)  ; one entry in the privileges array...
        ; Retrieves the locally unique identifier of the debug privilege:
        luid:=0
        DllCall("Advapi32.dll\LookupPrivilegeValue", "Ptr", 0, "Str", "SeDebugPrivilege", "Int64P", &luid)
        NumPut("Int64",luid, ti, 4)
        if enable
            NumPut("UInt",2, ti, 12)  ; enable this privilege: SE_PRIVILEGE_ENABLED = 2
        ; Update the privileges of this process with the new access token:
        r := DllCall("Advapi32.dll\AdjustTokenPrivileges", "Ptr", t, "Int", false, "Ptr", ti.Ptr, "UInt", 0, "Ptr", 0, "Ptr", 0)
        DllCall("CloseHandle", "Ptr", t)  ; close this access token handle to save memory
        DllCall("CloseHandle", "Ptr", h)  ; close this process handle to save memory
        return r
    }


    ; Method:  isTargetProcess64Bit(PID, hProcess := "", currentHandleAccess := "")
    ;          Determines if a process is 64 bit.
    ; Parameters:
    ;   PID                     The Process ID of the target process. If required this is used to open a temporary process handle.
    ;   hProcess                (Optional) A handle to the process, as returned by openProcess() i.e. [derivedObject].hProcess
    ;   currentHandleAccess     (Optional) The dwDesiredAccess value used when opening the process handle which has been
    ;                           passed as the hProcess parameter. If specifying hProcess, you should also specify this value.
    ; Return Values:
    ;   True    The target application is 64 bit.
    ;   False   The target application is 32 bit.
    ;   Null    The method failed.
    ; Notes:
    ;   This is an internal method which is called when the new operator is used. It is used to set the pointer type for 32/64 bit applications so the pointer methods will work.
    ;   This operation requires a handle with PROCESS_QUERY_INFORMATION or PROCESS_QUERY_LIMITED_INFORMATION access rights.
    ;   If the currentHandleAccess parameter does not contain these rights (or not passed) or if the hProcess (process handle) is invalid (or not passed)
    ;   a temporary handle is opened to perform this operation. Otherwise if hProcess and currentHandleAccess appear valid
    ;   the passed hProcess is used to perform the operation.

    isTargetProcess64Bit(PID, hProcess := 0, currentHandleAccess := 0)
    {
        closeHandle:=0
        if !A_Is64bitOS
            return False
        ; If insufficient rights, open a temporary handle
        else if !hProcess || !(currentHandleAccess & (ClassMemory.aRights.PROCESS_QUERY_INFORMATION | ClassMemory.aRights.PROCESS_QUERY_LIMITED_INFORMATION))
            closeHandle := hProcess := this.openProcess(PID, ClassMemory.aRights.PROCESS_QUERY_INFORMATION)
        Wow64Process:=0
        if (hProcess && DllCall("IsWow64Process", "Ptr", hProcess, "Int*", &Wow64Process))
            result := !Wow64Process
        if closeHandle
          this.CloseHandle(hProcess)
        return result
    }
    /*
        _Out_  PBOOL Wow64Proces value set to:
        True if the process is running under WOW64 - 32bit app on 64bit OS.
        False if the process is running under 32-bit Windows!
        False if the process is a 64-bit application running under 64-bit Windows.
    */

    getModules(&aModules, useFileNameAsKey := False)
    {
        if (A_PtrSize = 4 && this.IsTarget64bit)
            return -4 ; AHK is 32bit and target process is 64 bit, this function wont work
;        aModules := []
        lphModule:=Buffer(4)
        if !moduleCount := this.EnumProcessModulesEx(&lphModule)
            return -3
        loop moduleCount
        {
            aModuleInfo:=map()
            hModule := numget(lphModule, (A_index - 1) * A_PtrSize,"Ptr")
            this.GetModuleInformation(hModule, &aModuleInfo)
            aModuleInfo.Name := this.GetModuleFileNameEx(hModule)
            filePath := aModuleInfo.name
            SplitPath filePath, &fileName
            aModuleInfo.fileName := fileName
            if useFileNameAsKey
                aModules[fileName] := aModuleInfo
            else aModules.insert(aModuleInfo)
        }
        return moduleCount
    }

    ; lpFilename [out]
    ; A pointer to a buffer that receives the fully qualified path to the module.
    ; If the size of the file name is larger than the value of the nSize parameter, the function succeeds
    ; but the file name is truncated and null-terminated.
    ; If the buffer is adequate the string is still null terminated.

    GetModuleFileNameEx(hModule := 0, fileNameNoPath := False)
    {
        ; ANSI MAX_PATH = 260 (includes null) - unicode can be ~32K.... but no one would ever have one that size
        ; So just give it a massive size and don't bother checking. Most coders just give it MAX_PATH size anyway
        VarSetStrCapacity(&lpFilename,1024)
;        VarSetCapacity(lpFilename, 2048 * (A_IsUnicode ? 2 : 1))
        DllCall("psapi\GetModuleFileNameEx"
                    , "Ptr", this.hProcess
                    , "Ptr", hModule
                    , "Str", lpFilename
                    , "Uint", 1024)
        if fileNameNoPath
            SplitPath lpFilename, &lpFilename ; strips the path so = GDI32.dll

        return lpFilename
    }



    ; dwFilterFlag
    ;   LIST_MODULES_DEFAULT    0x0
    ;   LIST_MODULES_32BIT      0x01
    ;   LIST_MODULES_64BIT      0x02
    ;   LIST_MODULES_ALL        0x03
    ; If the function is called by a 32-bit application running under WOW64, the dwFilterFlag option
    ; is ignored and the function provides the same results as the EnumProcessModules function.
    EnumProcessModulesEx(&lphModule, dwFilterFlag := 0x03)
    {
;        lastError := A_LastError
        size := 4 ; VarSetCapacity(lphModule, 4)
        reqSize:=0
        loop
        {
            if !DllCall("psapi\EnumProcessModulesEx"
                        , "Ptr", this.hProcess
                        , "Ptr", lphModule.Ptr
                        , "Uint", size
                        , "Uint*", &reqSize
                        , "Uint", dwFilterFlag)
                return 0
            else if (size >= reqSize)
                break
            else
            {
                size := reqSize
                lphModule.__new(size)
            }
        }
        ; On first loop it fails with A_lastError = 0x299 as its meant to
        ; might as well reset it to its previous version
;        DllCall("SetLastError", "UInt", lastError)
        return reqSize // A_PtrSize ; module count  ; sizeof(HMODULE) - enumerate the array of HMODULEs
    }

    GetModuleInformation(hModule,&aModuleInfo)
    {
        MODULEINFO:=buffer(A_PtrSize * 3)
;        VarSetCapacity(MODULEINFO, A_PtrSize * 3)
;        aModuleInfo := []
        r:=DllCall("psapi\GetModuleInformation"
                    , "Ptr", this.hProcess
                    , "Ptr", hModule
                    , "Ptr", MODULEINFO.Ptr
                    , "UInt", A_PtrSize * 3)
        aModuleInfo := {  lpBaseOfDll: numget(MODULEINFO, 0, "Ptr")
                       ,  SizeOfImage: numget(MODULEINFO, A_PtrSize, "UInt")
                       ,   EntryPoint: numget(MODULEINFO, A_PtrSize * 2, "Ptr") }
        return r
    }
}

/* example; comment this line to try
o:={}
o.var:=1234567890
o.val:="test object property"
o.arr:=[{},{}]
o.arr[1].par:="asdf"
o.arr[1].val:=1234
o.arr[2].par:="jkl;"
o.arr[2].val:=5678
o.m:=map()
o.m.var:=123.0
o.m.val:="qwer"
o.m[11]:={}
o.m[11].par:="asdf"
o.m[11].val:=1234
o.m[22]:={}
o.m[22].par:="jkl;"
o.m[22].vasl:=5678
o.b:=Buffer(3,255)

SaveFileName:=a_desktop "\Dumped Object.test"
ObjDump(SaveFileName,o)
MyObj:=ObjLoad(SaveFileName)

msgbox MyObj.var
msgbox MyObj.val
msgbox MyObj.arr[1].par
msgbox MyObj.arr[1].val
msgbox MyObj.arr[2].par
msgbox MyObj.arr[2].val
msgbox MyObj.m.var
msgbox MyObj.m.val
msgbox MyObj.m[11].par
msgbox MyObj.m[11].val
msgbox MyObj.m[22].par
msgbox MyObj.m[22].vasl
msgbox NumGet(o.b,2,"UChar")
exitapp
esc::exitapp
/*
*/
ObjLoad(addr,&offset:=0) ; load dumped object to variable; from memory (addr is int) or from file (addr is string)
{
  ; #requires AutoHotkey v2.0.19
  If !IsNumber(addr)
  {
    If !FileExist(addr)
      return
    sz:=FileGetSize(addr)
    If !sz
      return
    Data:=FileRead(addr,"RAW")
    addr:=Data.Ptr
    sz:=NumGet(addr,"Int64")
    addr+=8
    obj:=0
  }
  ;    Sizes          1       1       2        2     4      4       8        8        8    x     x     x      x         x
  ;    Type.Enum: Char.1 UChar.2 Short.3 UShort.4 Int.5 UInt.6 Int64.7 UInt64.8 Double.9 Str.10 [].11 {}.12 map().13 buffer.14
  static types:=["Char","UChar","Short","UShort","Int","UInt","Int64","UInt64","Double"]
  static syzes:=[     2,      2,      3,       3,    5,     5,      9,       9,       9]
  typ:=NumGet(addr,offset,"Char")
  if (typ<10)
  {
    obj:=NumGet(addr,offset+1,types[typ])
    offset+=syzes[typ]
  }
  else if (typ=10)
  {
    size:=NumGet(addr,offset+1,"Int64")
    obj:=StrGet(addr+offset+9,size)
    offset+=9+size
  }
  else if (typ=11)
  {
    obj:=[]
    size:=NumGet(addr,offset+1,"Int64")
    obj.Length:=size
    offset+=9
    loop size
      obj[a_index]:=ObjLoad(addr,&offset)
  }
  else if (typ=12)
  {
    obj:={}
    Props:=NumGet(addr,offset+1,"Int64")
    offset+=9
    loop Props
    {
      k:=ObjLoad(addr,&offset)
      obj.%k%:=ObjLoad(addr,&offset)
    }
  }
  else if (typ=13)
  {
    obj:=Map()
    Props:=NumGet(addr,offset+1,"Int64")
    Items:=NumGet(addr,offset+9,"Int64")
    offset+=17
    loop Props
    {
      k:=ObjLoad(addr,&offset)
      obj.%k%:=ObjLoad(addr,&offset)
    }
    loop Items
    {
      i:=ObjLoad(addr,&offset)
      obj[i]:=ObjLoad(addr,&offset)
    }
  }
  else if (typ=14)
  {
    size:=NumGet(addr,offset+1,"Int64")
    obj:=Buffer(size)
    offset+=9
    loop size
      NumPut("UChar",NumGet(addr,offset+a_index-1,"UChar"),obj,a_index-1)
    offset+=size
  }
  return obj
}

ObjDump(Path,obj) ; dump object to file
{
  ; #requires AutoHotkey v2.0.19
  if !sz:=RawObjectSize(obj)
    return
  If FileExist(Path)
    FileDelete Path
  sz+=8
  Data:=Buffer(sz,0)
  ptr:=Data.Ptr
  NumPut("Int64",sz-8,ptr) ;size of all data
  RawObject(obj,ptr+8) ; use this for dumping to memory instead of ObjDump
  f:=FileOpen(Path,"rw-rwd","CP0")
  Loop (sz//65536)
    f.RawWrite(ptr,65536),ptr+=65536
  f.RawWrite(ptr,Mod(sz,65536))
  f.Close()
  return sz
}
RawObject(obj,ptr,offset:=0) ; dump object to memory
{
  ; #requires AutoHotkey v2.0.19
  ;    Sizes          1       1       2        2     4      4       8        8        8    x     x     x      x         x
  ;    Type.Enum: Char.1 UChar.2 Short.3 UShort.4 Int.5 UInt.6 Int64.7 UInt64.8 Double.9 Str.10 [].11 {}.12 map().13 buffer.14
  if isObject(Obj)
  {
    if (Obj.base=[].base)
    {
      NumPut("Char",11,ptr,offset) ; type
      NumPut("Int64",Obj.Length,ptr,offset+1) ; Length of array
      offset+=9
      loop Obj.Length
        offset:=RawObject(Obj[a_index],ptr,offset)
    }
    else if (Obj.base={}.base)
    {
      NumPut("Char",12,ptr,offset) ; type
      NumPut("Int64",ObjOwnPropCount(Obj),ptr,offset+1) ; num of Props
      offset+=9
      for k,v in Obj.OwnProps()
      {
        offset:=RawObject(k,ptr,offset) ; name of prop (str)
        offset:=RawObject(v,ptr,offset) ; value of prop (any)
      }
    }
    else if (Obj.base=Map().base)
    {
      NumPut("Char",13,ptr,offset) ; type
      NumPut("Int64",ObjOwnPropCount(Obj),ptr,offset+1) ; num of Props
      NumPut("Int64",Obj.Count,ptr,offset+9) ; num of items
      offset+=17
      for k,v in Obj.OwnProps()
      {
        offset:=RawObject(k,ptr,offset) ; name of prop (str)
        offset:=RawObject(v,ptr,offset) ; value of prop (any)
      }
      for k,v in Obj
      {
        offset:=RawObject(k,ptr,offset) ; index of item (any)
        offset:=RawObject(v,ptr,offset) ; value of item (any)
      }
    }
    else if (Obj.base=Buffer().base)
    {
      NumPut("Char",14,ptr,offset) ; type
      NumPut("Int64",Obj.size,ptr,offset+1) ; num of bytes
      offset+=9
      loop Obj.size
        NumPut("UChar",NumGet(Obj,a_index-1,"UChar"),ptr,offset+a_index-1) ; Buffer content (RAW)
      offset+=Obj.size
    }
  }
  else if IsNumber(obj) ; num
  {
    NumPut("Char",IsFloat(Obj)?9:Obj>4294967295?8       :Obj>65535?6     :Obj>255?4       :Obj>-1?2      :Obj>-129?1     :Obj>-32769?3      :Obj>-2147483649?5    :7,ptr,offset+0)
    NumPut(IsFloat(Obj)?"Double":Obj>4294967295?"UInt64":Obj>65535?"UInt":Obj>255?"UShort":Obj>-1?"UChar":Obj>-129?"Char":Obj>-32769?"Short":Obj>-2147483649?"Int":"Int64",Obj,ptr,offset+1)
    offset+=       IsFloat(Obj)||Obj>4294967295?9       :Obj>65535?5     :Obj>255?3                      :Obj>-129?2     :Obj>-32769?3      :Obj>-2147483649?5    :9
  }
  else ; string
  {
    NumPut("Char",10,ptr,offset)  ; type
    NumPut("Int64",sz:=StrPut(Obj,ptr+offset+9),ptr,offset+1) ; (str size) string text
    offset+=sz+9
  }
  return offset
}

RawObjectSize(Obj,sz:=0) ; get object's size in dumped condition
{
  ; #requires AutoHotkey v2.0.19
  if isObject(Obj)
  {
    if (Obj.base=[].base)
    {
      sz+=9 ; 1 (type) + 8 (num of items)
      loop Obj.Length
        sz:=RawObjectSize(Obj[a_index],sz)
    }
    else if (Obj.base={}.base)
    {
      sz+=9 ; 1 (type) + 8 (num of prop)
      for k,v in Obj.OwnProps()
      {
        sz:=RawObjectSize(k,sz) ; name of prop (str)
        sz:=RawObjectSize(v,sz) ; value of prop (any)
      }
    }
    else if (Obj.base=Map().base)
    {
      sz+=17 ; 1 (type) + 8 (size of Props) + 8 (size of array)
      for k,v in Obj.OwnProps()
      {
        sz:=RawObjectSize(k,sz) ; name of prop (str)
        sz:=RawObjectSize(v,sz) ; value of prop (any)
      }
      for k,v in Obj
      {
        sz:=RawObjectSize(k,sz) ; index
        sz:=RawObjectSize(v,sz) ; value
      }
    }
    else if (Obj.base=Buffer().base) ; sz = 1 (type) + 8 (size) + (buffer size)
      sz+=9+Obj.size
    else
    {
      MsgBox "Unsupported object type: `"" Type(obj) "`".","ObjDump",0x30
      return 0
    }
  }
  else if IsNumber(obj) ; sz = 1 (type) + (size of data type)
    sz+=IsFloat(Obj)||Obj>4294967295?9:Obj>65535?5:Obj>255?3:Obj>-129?2:Obj>-32769?3:Obj>-2147483649?5:9
  else ; sz = 1 (type) + 8 (size) + (str size)
    sz+=9+StrPut(Obj)
  return sz
}

;#Requires AutoHotkey v2.0.19

#SingleInstance off  ; здесь просто привычный набор параметров, ничего особенного
CoordMode "ToolTip"
SetControlDelay -1
SetKeyDelay -1
SetWinDelay -1
SetWorkingDir A_ScriptDir
DetectHiddenWindows true
#NoTrayIcon
onexit Exit


; создаем память которая будет общей для двух потоков
DataSize:=1000
Data:=Buffer(DataSize)

; псевдо-структура (смещения в общей памяти)
_MainCycleNum:=0 ; uint = 4 byte
_SlaveCycleNum:=4 ; uint = 4 byte
_MainString:=8, MainStringSize:=12 ; string
_SlaveString:=32 ,SlaveStringSize:=50 ; string


; принимаем параметры для второго потока
SecondThread:=DataPointer:=0
if (A_Args.Length=2)
{
  SecondThread:=A_Args[1] ; PID первого потока.
  DataPointer:=A_Args[2] ; указатель на общую память.
}

if !SecondThread ; код первого потока здесь
{
  MainPID:=DllCall("GetCurrentProcessId") ; берем PID первого потока

; добавляем горячих клавиш по вкусу, через команду HotKey
  HotKey "Esc",exit
; не советую добавлять их обычным методом, иначе второй поток будет тоже их обрабатывать

; запускаем второй поток и передаем ему параметры
  if a_iscompiled
  {
    run a_scriptfullpath " " MainPID " " Data.Ptr,,,&SlavePID
  }
  else
  {
    run "`"" a_ahkPath "`" `"" a_scriptfullpath "`" " MainPID " " Data.Ptr,,,&SlavePID
  }
  ; ---------

; запускаем контроль наличия второго потока, если его нет то завершаем скрипт
  F:=CheckPIDExist.Bind(SlavePID)
  settimer F,2000

MainLoop: ; просто метка для ориентации в коде
  loop ; основной цикл первого потока (""""секция автовыполнения"""")
  {
    sleep 500
    NumPut("uint",a_index,Data,_MainCycleNum) ; пишем номер цикла в общую память (данные для второго потока)
    tmp0:=NumGet(Data,_SlaveCycleNum,"uint") ; читаем данные из общей памяти (данные от второго потока)

    tmp1:=StrGet(Data.Ptr+_SlaveString,SlaveStringSize) ; читаем строку
    StrPut("Hello World!",Data.Ptr+_MainString,MainStringSize) ; пишем строку
; выводим на экран
    tooltip "Main Script`nMainPID=" MainPID "`nSlavePID=" SlavePID "`nA_Index = " a_index "`nData from slave:`n`t" tmp0 "`n`t" tmp1,0,500
  }
}
else ; код второго потока здесь
{
; запускаем контроль наличия первого потока, если его нет то завершаем скрипт
  MainPID:=SecondThread
  F:=CheckPIDExist.Bind(MainPID)
  settimer F,2000

  SlavePID:=DllCall("GetCurrentProcessId")
  A_IconHidden:=false

; получаем объект для работы с памятью первого потока
  MainMemory := ClassMemory("Ahk_PID" MainPID)

SlaveLoop: ; просто метка для ориентации в коде
  loop ; основной цикл второго потока (""""секция автовыполнения"""")
  {
    sleep 100
    MainMemory.readRaw(DataPointer,Data,DataSize) ; читаем общую память в переменную "Data"
    MainMemory.write(DataPointer+_SlaveCycleNum,A_Index) ; пишем номер цикла в общую память (данные для первого потока)
    tmp0:=numget(Data,_MainCycleNum,"Uint") ; читаем данные из общей памяти (данные от первого потока)

    tmp1:=StrGet(Data.Ptr+_MainString,MainStringSize) ; читаем строку

    str:=buffer(SlaveStringSize) ; пишем строку
    StrPut("Hello Yourself!",str.Ptr,SlaveStringSize) ; пишем строку
    MainMemory.writeRaw(DataPointer+_SlaveString,str,SlaveStringSize) ; пишем строку

; выводим на экран
    tooltip "Slave Script`nMainPID=" MainPID "`nSlavePID=" SlavePID "`nA_Index = " a_index "`nData from main:`n`t" tmp0 "`n`t" tmp1,200,500
  }
}


CheckPIDExist(PID)
{
  if !ProcessExist(PID)
    Exit()
}

exit(*)
{
  exitapp
}

; в этом месте можно добавлять метки перехода для интерфейса и т.д.




; библиотека

; Переделанный и урезанный basic memory class by RHCP:
; https://github.com/Kalamity/classMemory
class ClassMemory
{
    ; List of useful accessible values. Some of these inherited values (the non objects) are set when the new operator is used.

    static aTypeSize := {    UChar:    1,  Char:     1
                    ,   UShort:   2,  Short:    2
                    ,   UInt:     4,  Int:      4
                    ,   UFloat:   4,  Float:    4
                    ,   Int64:    8,  Double:   8}
    static aRights := {  PROCESS_ALL_ACCESS: 0x001F0FFF
                ,   PROCESS_CREATE_PROCESS: 0x0080
                ,   PROCESS_CREATE_THREAD: 0x0002
                ,   PROCESS_DUP_HANDLE: 0x0040
                ,   PROCESS_QUERY_INFORMATION: 0x0400
                ,   PROCESS_QUERY_LIMITED_INFORMATION: 0x1000
                ,   PROCESS_SET_INFORMATION: 0x0200
                ,   PROCESS_SET_QUOTA: 0x0100
                ,   PROCESS_SUSPEND_RESUME: 0x0800
                ,   PROCESS_TERMINATE: 0x0001
                ,   PROCESS_VM_OPERATION: 0x0008
                ,   PROCESS_VM_READ: 0x0010
                ,   PROCESS_VM_WRITE: 0x0020
                ,   SYNCHRONIZE: 0x00100000}

    ; Method:    __new(program, dwDesiredAccess := "", byRef handle := "", windowMatchMode := 3)
    ; Example:  derivedObject := new _ClassMemory("ahk_exe calc.exe")
    ;           This is the first method which should be called when trying to access a program's memory.
    ;           If the process is successfully opened, an object is returned which can be used to read that processes memory space.
    ;           [derivedObject].hProcess stores the opened handle.
    ;           If the target process closes and re-opens, simply free the derived object and use the new operator again to open a new handle.
    ; Parameters:
    ;   program             The program to be opened. This can be any AHK windowTitle identifier, such as
    ;                       ahk_exe, ahk_class, ahk_pid, or simply the window title. e.g. "ahk_exe calc.exe" or "Calculator".
    ;                       It's safer not to use the window title, as some things can have the same window title e.g. an open folder called "Starcraft II"
    ;                       would have the same window title as the game itself.
    ;                       *'DetectHiddenWindows, On' is required for hidden windows*
    ;   dwDesiredAccess     The access rights requested when opening the process.
    ;                       If this parameter is null the process will be opened with the following rights
    ;                       PROCESS_QUERY_INFORMATION, PROCESS_VM_OPERATION, PROCESS_VM_READ, PROCESS_VM_WRITE, & SYNCHRONIZE
    ;                       This access level is sufficient to allow all of the methods in this class to work.
    ;                       Specific process access rights are listed here http://msdn.microsoft.com/en-us/library/windows/desktop/ms684880(v=vs.85).aspx
    ;   handle (Output)     Optional variable in which a copy of the opened processes handle will be stored.
    ;                       Values:
    ;                           Null    OpenProcess failed. The script may need to be run with admin rights admin,
    ;                                   and/or with the use of _ClassMemory.setSeDebugPrivilege(). Consult A_LastError for more information.
    ;                           0       The program isn't running (not found) or you passed an incorrect program identifier parameter.
    ;                                   In some cases _ClassMemory.setSeDebugPrivilege() may be required.
    ;                           Positive Integer    A handle to the process. (Success)
    ;   windowMatchMode -   Determines the matching mode used when finding the program (windowTitle).
    ;                       The default value is 3 i.e. an exact match. Refer to AHK's setTitleMathMode for more information.
    ; Return Values:
    ;   Object  On success an object is returned which can be used to read the processes memory.
    ;   Null    Failure. A_LastError and the optional handle parameter can be consulted for more information.


    __new(program, dwDesiredAccess := "", handle := "", windowMatchMode := 3)
    {
        DHW:=A_DetectHiddenWindows
        DetectHiddenWindows true
        if this.PID := handle := this.findPID(program, windowMatchMode) ; set handle to 0 if program not found
        {
            ; This default access level is sufficient to read and write memory addresses, and to perform pattern scans.
            ; if the program is run using admin privileges, then this script will also need admin privileges
            if !IsInteger(dwDesiredAccess)
                dwDesiredAccess := ClassMemory.aRights.PROCESS_QUERY_INFORMATION | ClassMemory.aRights.PROCESS_VM_OPERATION | ClassMemory.aRights.PROCESS_VM_READ | ClassMemory.aRights.PROCESS_VM_WRITE
            dwDesiredAccess |= ClassMemory.aRights.SYNCHRONIZE ; add SYNCHRONIZE to all handles to allow isHandleValid() to work

            if this.hProcess := handle := this.OpenProcess(this.PID, dwDesiredAccess) ; NULL/Blank if failed to open process for some reason
            {
                this.pNumberOfBytesRead := DllCall("GlobalAlloc", "UInt", 0x0040, "Ptr", A_PtrSize, "Ptr") ; 0x0040 initialise to 0
                this.pNumberOfBytesWritten := DllCall("GlobalAlloc", "UInt", 0x0040, "Ptr", A_PtrSize, "Ptr") ; initialise to 0

                this.readStringLastError := False
                this.currentProgram := program
                if this.isTarget64bit := this.isTargetProcess64Bit(this.PID, this.hProcess, dwDesiredAccess)
                    this.ptrType := "Int64"
                else this.ptrType := "UInt" ; If false or Null (fails) assume 32bit

                ; if script is 64 bit, getModuleBaseAddress() should always work
                ; if target app is truly 32 bit, then getModuleBaseAddress()
                ; will work when script is 32 bit
                if (A_PtrSize != 4 || !this.isTarget64bit)
                    this.BaseAddress := this.getModuleBaseAddress()

                ; If the above failed or wasn't called, fall back to alternate method
                if this.BaseAddress < 0 || !this.BaseAddress
                    this.BaseAddress := this.getProcessBaseAddress(program, windowMatchMode)
                DetectHiddenWindows DHW
                return this
            }
        }
        DetectHiddenWindows DHW
        return
    }

    __delete()
    {
        this.closeHandle(this.hProcess)
        if this.pNumberOfBytesRead
            DllCall("GlobalFree", "Ptr", this.pNumberOfBytesRead)
        if this.pNumberOfBytesWritten
            DllCall("GlobalFree", "Ptr", this.pNumberOfBytesWritten)
        return
    }

    version()
    {
        return 9999.9999
    }

    findPID(program, windowMatchMode := "3")
    {
        ; If user passes an AHK_PID, don't bother searching. There are cases where searching windows for PIDs
        ; wont work - console apps
        if RegExMatch(program, "i)\s*AHK_PID\s+(0x[[:xdigit:]]+|\d+)", &pid)
            return pid[1]
        if windowMatchMode
        {
            ; This is a string and will not contain the 0x prefix
            mode := A_TitleMatchMode
            ; remove hex prefix as SetTitleMatchMode will throw a run time error. This will occur if integer mode is set to hex and user passed an int (unquoted)
            windowMatchMode:=StrReplace(windowMatchMode,"0x")
;            StringReplace, windowMatchMode, windowMatchMode, 0x
            SetTitleMatchMode windowMatchMode
        }
        pid:=WinGetPid(program)
        if windowMatchMode
            SetTitleMatchMode mode    ; In case executed in autoexec

        ; If use 'ahk_exe test.exe' and winget fails (which can happen when setSeDebugPrivilege is required),
        ; try using the process command. When it fails due to setSeDebugPrivilege, setSeDebugPrivilege will still be required to openProcess
        ; This should also work for apps without windows.
        if (!pid && RegExMatch(program, "i)\bAHK_EXE\b\s*(.*)", &fileNm))
        {
            ; remove any trailing AHK_XXX arguments
            filename := RegExReplace(fileNm[1], "i)\bahk_(class|id|pid|group)\b.*", "")
            filename := trim(filename)    ; extra spaces will make process command fail
            ; AHK_EXE can be the full path, so just get filename
            SplitPath fileName , &fileName
            if (fileName) ; if filename blank, scripts own pid is returned
                pid := ProcessExist(fileName)
        }

        return pid ? pid : 0 ; PID is null on fail, return 0
    }

    ; Method:   isHandleValid()
    ;           This method provides a means to check if the internal process handle is still valid
    ;           or in other words, the specific target application instance (which you have been reading from)
    ;           has closed or restarted.
    ;           For example, if the target application closes or restarts the handle will become invalid
    ;           and subsequent calls to this method will return false.
    ;
    ; Return Values:
    ;   True    The handle is valid.
    ;   False   The handle is not valid.
    ;
    ; Notes:
    ;   This operation requires a handle with SYNCHRONIZE access rights.
    ;   All handles, even user specified ones are opened with the SYNCHRONIZE access right.

    isHandleValid()
    {
        return 0x102 = DllCall("WaitForSingleObject", "Ptr", this.hProcess, "UInt", 0)
        ; WaitForSingleObject return values
        ; -1 if called with null hProcess (sets lastError to 6 - invalid handle)
        ; 258 / 0x102 WAIT_TIMEOUT - if handle is valid (process still running)
        ; 0  WAIT_OBJECT_0 - if process has terminated
    }

    ; Method:   openProcess(PID, dwDesiredAccess)
    ;           ***Note:    This is an internal method which shouldn't be called directly unless you absolutely know what you are doing.
    ;                       This is because the new operator, in addition to calling this method also sets other values
    ;                       which are required for the other methods to work correctly.
    ; Parameters:
    ;   PID                 The Process ID of the target process.
    ;   dwDesiredAccess     The access rights requested when opening the process.
    ;                       Specific process access rights are listed here http://msdn.microsoft.com/en-us/library/windows/desktop/ms684880(v=vs.85).aspx
    ; Return Values:
    ;   Null/blank          OpenProcess failed. If the target process has admin rights, then the script also needs to be ran as admin.
    ;                       _ClassMemory.setSeDebugPrivilege() may also be required.
    ;   Positive integer    A handle to the process.

    openProcess(PID, dwDesiredAccess)
    {
        r := DllCall("OpenProcess", "UInt", dwDesiredAccess, "Int", False, "UInt", PID, "Ptr")
        ; if it fails with 0x5 ERROR_ACCESS_DENIED, try enabling privilege ... lots of users never try this.
        ; there may be other errors which also require DebugPrivilege....
        if (!r && A_LastError = 5)
        {
            this.setSeDebugPrivilege(true) ; no harm in enabling it if it is already enabled by user
            if (r2 := DllCall("OpenProcess", "UInt", dwDesiredAccess, "Int", False, "UInt", PID, "Ptr"))
                return r2
            DllCall("SetLastError", "UInt", 5) ; restore original error if it doesnt work
        }
        ; If fails with 0x5 ERROR_ACCESS_DENIED (when setSeDebugPrivilege() is req.), the func. returns 0 rather than null!! Set it to null.
        ; If fails for another reason, then it is null.
        return r ? r : 0
    }

    ; Method:   closeHandle(hProcess)
    ;           Note:   This is an internal method which is automatically called when the script exits or the derived object is freed/destroyed.
    ;                   There is no need to call this method directly. If you wish to close the handle simply free the derived object.
    ;                   i.e. derivedObject := [] ; or derivedObject := ""
    ; Parameters:
    ;   hProcess        The handle to the process, as returned by openProcess().
    ; Return Values:
    ;   Non-Zero        Success
    ;   0               Failure

    closeHandle(hProcess)
    {
        return DllCall("CloseHandle", "Ptr", hProcess)
    }

    ; Methods:      numberOfBytesRead() / numberOfBytesWritten()
    ;               Returns the number of bytes read or written by the last ReadProcessMemory or WriteProcessMemory operation.
    ;
    ; Return Values:
    ;   zero or positive value      Number of bytes read/written
    ;   -1                          Failure. Shouldn't occur

    numberOfBytesRead()
    {
        return !this.pNumberOfBytesRead ? -1 : NumGet(this.pNumberOfBytesRead+0, "Ptr")
    }
    numberOfBytesWritten()
    {
        return !this.pNumberOfBytesWritten ? -1 : NumGet(this.pNumberOfBytesWritten+0, "Ptr")
    }


    ; Method:   read(address, type := "UInt", aOffsets*)
    ;           Reads various integer type values
    ; Parameters:
    ;       address -   The memory address of the value or if using the offset parameter,
    ;                   the base address of the pointer.
    ;       type    -   The integer type.
    ;                   Valid types are UChar, Char, UShort, Short, UInt, Int, Float, Int64 and Double.
    ;                   Note: Types must not contain spaces i.e. " UInt" or "UInt " will not work.
    ;                   When an invalid type is passed the method returns NULL and sets ErrorLevel to -2
    ;       aOffsets* - A variadic list of offsets. When using offsets the address parameter should equal the base address of the pointer.
    ;                   The address (base address) and offsets should point to the memory address which holds the integer.
    ; Return Values:
    ;       integer -   Indicates success.
    ;       Null    -   Indicates failure. Check ErrorLevel and A_LastError for more information.
    ;       Note:       Since the returned integer value may be 0, to check for success/failure compare the result
    ;                   against null i.e. if (result = "") then an error has occurred.
    ;                   When reading doubles, adjusting "SetFormat, float, totalWidth.DecimalPlaces"
    ;                   may be required depending on your requirements.

    read(address, type := "UInt")
    {
        ; If invalid type RPM() returns success (as bytes to read resolves to null in dllCall())
        ; so set errorlevel to invalid parameter for DLLCall() i.e. -2
        if !ClassMemory.aTypeSize.%type%
            return false
        result:=0
        if DllCall("ReadProcessMemory", "Ptr", this.hProcess, "Ptr", address, type "*", &result, "Ptr", ClassMemory.aTypeSize.%type%, "Ptr", this.pNumberOfBytesRead)
            return result
        return
    }

    ; Method:   readRaw(address, byRef buffer, bytes := 4, aOffsets*)
    ;           Reads an area of the processes memory and stores it in the buffer variable
    ; Parameters:
    ;       address  -  The memory address of the area to read or if using the offsets parameter
    ;                   the base address of the pointer which points to the memory region.
    ;       buffer   -  The unquoted variable name for the buffer. This variable will receive the contents from the address space.
    ;                   This method calls varsetCapcity() to ensure the variable has an adequate size to perform the operation.
    ;                   If the variable already has a larger capacity (from a previous call to varsetcapcity()), then it will not be shrunk.
    ;                   Therefore it is the callers responsibility to ensure that any subsequent actions performed on the buffer variable
    ;                   do not exceed the bytes which have been read - as these remaining bytes could contain anything.
    ;       bytes   -   The number of bytes to be read.
    ;       aOffsets* - A variadic list of offsets. When using offsets the address parameter should equal the base address of the pointer.
    ;                   The address (base address) and offsets should point to the memory address which is to be read
    ; Return Values:
    ;       Non Zero -   Indicates success.
    ;       Zero     -   Indicates failure. Check errorLevel and A_LastError for more information
    ;
    ; Notes:            The contents of the buffer may then be retrieved using AHK's NumGet() and StrGet() functions.
    ;                   This method offers significant (~30% and up) performance boost when reading large areas of memory.
    ;                   As calling ReadProcessMemory for four bytes takes a similar amount of time as it does for 1,000 bytes.

    readRaw(address, buffer, bytes := 4)
    {
;        Data.__new(bytes)
        return DllCall("ReadProcessMemory", "Ptr", this.hProcess, "Ptr", address, "Ptr", IsInteger(Buffer)?Buffer:buffer.ptr, "Ptr", bytes, "Ptr", this.pNumberOfBytesRead)
    }

    ; Method:   write(address, value, type := "Uint", aOffsets*)
    ;           Writes various integer type values to the process.
    ; Parameters:
    ;       address -   The memory address to which data will be written or if using the offset parameter,
    ;                   the base address of the pointer.
    ;       type    -   The integer type.
    ;                   Valid types are UChar, Char, UShort, Short, UInt, Int, Float, Int64 and Double.
    ;                   Note: Types must not contain spaces i.e. " UInt" or "UInt " will not work.
    ;                   When an invalid type is passed the method returns NULL and sets ErrorLevel to -2
    ;       aOffsets* - A variadic list of offsets. When using offsets the address parameter should equal the base address of the pointer.
    ;                   The address (base address) and offsets should point to the memory address which is to be written to.
    ; Return Values:
    ;       Non Zero -  Indicates success.
    ;       Zero     -  Indicates failure. Check errorLevel and A_LastError for more information
    ;       Null    -   An invalid type was passed. Errorlevel is set to -2

    write(address, value, type := "Uint")
    {
        if !ClassMemory.aTypeSize.%type%
            return false
        return DllCall("WriteProcessMemory", "Ptr", this.hProcess, "Ptr", address, type "*", &value, "Ptr", ClassMemory.aTypeSize.%type%, "Ptr", this.pNumberOfBytesWritten)
    }

    ; Method:   writeRaw(address, pBuffer, sizeBytes, aOffsets*)
    ;           Writes a buffer to the process.
    ; Parameters:
    ;   address -       The memory address to which the contents of the buffer will be written
    ;                   or if using the offset parameter, the base address of the pointer.
    ;   pBuffer -       A pointer to the buffer which is to be written.
    ;                   This does not necessarily have to be the beginning of the buffer itself e.g. pBuffer := &buffer + offset
    ;   sizeBytes -     The number of bytes which are to be written from the buffer.
    ;   aOffsets* -     A variadic list of offsets. When using offsets the address parameter should equal the base address of the pointer.
    ;                   The address (base address) and offsets should point to the memory address which is to be written to.
    ; Return Values:
    ;       Non Zero -  Indicates success.
    ;       Zero     -  Indicates failure. Check errorLevel and A_LastError for more information

    writeRaw(address, Buffer, sizeBytes)
    {
        return DllCall("WriteProcessMemory", "Ptr", this.hProcess, "Ptr", address, "Ptr", IsInteger(Buffer)?Buffer:Buffer.Ptr, "Ptr", sizeBytes, "Ptr", this.pNumberOfBytesWritten)
    }

    ; Interesting note:
    ; Although handles are 64-bit pointers, only the less significant 32 bits are employed in them for the purpose
    ; of better compatibility (for example, to enable 32-bit and 64-bit processes interact with each other)
    ; Here are examples of such types: HANDLE, HWND, HMENU, HPALETTE, HBITMAP, etc.
    ; http://www.viva64.com/en/k/0005/



    ; Method:   getProcessBaseAddress(WindowTitle, windowMatchMode := 3)
    ;           Returns the base address of a process. In most cases this will provide the same result as calling getModuleBaseAddress() (when passing
    ;           a null value as the module parameter), however getProcessBaseAddress() will usually work regardless of the bitness
    ;           of both the AHK exe and the target process.
    ;           *This method relies on the target process having a window and will not work for console apps*
    ;           *'DetectHiddenWindows, On' is required for hidden windows*
    ;           ***If this returns an incorrect value, try using (the MORE RELIABLE) getModuleBaseAddress() instead.***
    ; Parameters:
    ;   windowTitle         This can be any AHK windowTitle identifier, such as
    ;                       ahk_exe, ahk_class, ahk_pid, or simply the window title. e.g. "ahk_exe calc.exe" or "Calculator".
    ;                       It's safer not to use the window title, as some things can have the same window title e.g. an open folder called "Starcraft II"
    ;                       would have the same window title as the game itself.
    ;   windowMatchMode     Determines the matching mode used when finding the program's window (windowTitle).
    ;                       The default value is 3 i.e. an exact match. The current matchmode will be used if the parameter is null or 0.
    ;                       Refer to AHK's setTitleMathMode for more information.
    ; Return Values:
    ;   Positive integer    The base address of the process (success).
    ;   Null                The process's window couldn't be found.
    ;   0                   The GetWindowLong or GetWindowLongPtr call failed. Try getModuleBaseAddress() instead.


    getProcessBaseAddress(windowTitle, windowMatchMode := "3")
    {
        mode:=0
        if (windowMatchMode && A_TitleMatchMode != windowMatchMode)
        {
            mode := A_TitleMatchMode ; This is a string and will not contain the 0x prefix
            windowMatchMode:=StrReplace(windowMatchMode,"0x")
;            StringReplace windowMatchMode, windowMatchMode, 0x ; remove hex prefix as SetTitleMatchMode will throw a run time error. This will occur if integer mode is set to hex and matchmode param is passed as an number not a string.
            SetTitleMatchMode windowMatchMode    ;mode 3 is an exact match
        }
        hWnd:=WinGetID(WindowTitle)
        if mode
            SetTitleMatchMode mode    ; In case executed in autoexec
        if !hWnd
            return 0 ; return blank failed to find window
      ; GetWindowLong returns a Long (Int) and GetWindowLongPtr return a Long_Ptr
        return DllCall(A_PtrSize = 4     ; If DLL call fails, returned value will = 0
            ? "GetWindowLong"
            : "GetWindowLongPtr"
            , "Ptr", hWnd, "Int", -6, A_Is64bitOS ? "Int64" : "UInt")
            ; For the returned value when the OS is 64 bit use Int64 to prevent negative overflow when AHK is 32 bit and target process is 64bit
            ; however if the OS is 32 bit, must use UInt, otherwise the number will be huge (however it will still work as the lower 4 bytes are correct)
            ; Note - it's the OS bitness which matters here, not the scripts/AHKs
    }

    ; http://winprogger.com/getmodulefilenameex-enumprocessmodulesex-failures-in-wow64/
    ; http://stackoverflow.com/questions/3801517/how-to-enum-modules-in-a-64bit-process-from-a-32bit-wow-process

    ; Method:            getModuleBaseAddress(module := "", byRef aModuleInfo := "")
    ; Parameters:
    ;   moduleName -    The file name of the module/dll to find e.g. "calc.exe", "GDI32.dll", "Bass.dll" etc
    ;                   If no module (null) is specified, the address of the base module - main()/process will be returned
    ;                   e.g. for calc.exe the following two method calls are equivalent getModuleBaseAddress() and getModuleBaseAddress("calc.exe")
    ;   aModuleInfo -   (Optional) A module Info object is returned in this variable. If method fails this variable is made blank.
    ;                   This object contains the keys: name, fileName, lpBaseOfDll, SizeOfImage, and EntryPoint
    ; Return Values:
    ;   Positive integer - The module's base/load address (success).
    ;   -1 - Module not found
    ;   -3 - EnumProcessModulesEx failed
    ;   -4 - The AHK script is 32 bit and you are trying to access the modules of a 64 bit target process. Or the target process has been closed.
    ; Notes:    A 64 bit AHK can enumerate the modules of a target 64 or 32 bit process.
    ;           A 32 bit AHK can only enumerate the modules of a 32 bit process
    ;           This method requires PROCESS_QUERY_INFORMATION + PROCESS_VM_READ access rights. These are included by default with this class.

    getModuleBaseAddress()
    {
        moduleName := this.GetModuleFileNameEx(0, True) ; main executable module of the process - get just fileName no path
        aModules:=map()
        if (r := this.getModules(&aModules, True) < 0)
            return r ; -4, -3
        return aModules.has(moduleName) ? (aModules[moduleName].lpBaseOfDll) : -1
        ; no longer returns -5 for failed to get module info
    }

    ; SeDebugPrivileges is required to read/write memory in some programs.
    ; This only needs to be called once when the script starts,
    ; regardless of the number of programs being read (or if the target programs restart)
    ; Call this before attempting to call any other methods in this class
    ; i.e. call _ClassMemory.setSeDebugPrivilege() at the very start of the script.

    setSeDebugPrivilege(enable := True)
    {
        h := DllCall("OpenProcess", "UInt", 0x0400, "Int", false, "UInt", DllCall("GetCurrentProcessId"), "Ptr")
        ; Open an adjustable access token with this process (TOKEN_ADJUST_PRIVILEGES = 32)
        t:=0
        DllCall("Advapi32.dll\OpenProcessToken", "Ptr", h, "UInt", 32, "PtrP", &t)
        ti:=Buffer(16,0)
;        VarSetCapacity(ti, 16, 0)  ; structure of privileges
        NumPut("UInt",1, ti, 0)  ; one entry in the privileges array...
        ; Retrieves the locally unique identifier of the debug privilege:
        luid:=0
        DllCall("Advapi32.dll\LookupPrivilegeValue", "Ptr", 0, "Str", "SeDebugPrivilege", "Int64P", &luid)
        NumPut("Int64",luid, ti, 4)
        if enable
            NumPut("UInt",2, ti, 12)  ; enable this privilege: SE_PRIVILEGE_ENABLED = 2
        ; Update the privileges of this process with the new access token:
        r := DllCall("Advapi32.dll\AdjustTokenPrivileges", "Ptr", t, "Int", false, "Ptr", ti.Ptr, "UInt", 0, "Ptr", 0, "Ptr", 0)
        DllCall("CloseHandle", "Ptr", t)  ; close this access token handle to save memory
        DllCall("CloseHandle", "Ptr", h)  ; close this process handle to save memory
        return r
    }


    ; Method:  isTargetProcess64Bit(PID, hProcess := "", currentHandleAccess := "")
    ;          Determines if a process is 64 bit.
    ; Parameters:
    ;   PID                     The Process ID of the target process. If required this is used to open a temporary process handle.
    ;   hProcess                (Optional) A handle to the process, as returned by openProcess() i.e. [derivedObject].hProcess
    ;   currentHandleAccess     (Optional) The dwDesiredAccess value used when opening the process handle which has been
    ;                           passed as the hProcess parameter. If specifying hProcess, you should also specify this value.
    ; Return Values:
    ;   True    The target application is 64 bit.
    ;   False   The target application is 32 bit.
    ;   Null    The method failed.
    ; Notes:
    ;   This is an internal method which is called when the new operator is used. It is used to set the pointer type for 32/64 bit applications so the pointer methods will work.
    ;   This operation requires a handle with PROCESS_QUERY_INFORMATION or PROCESS_QUERY_LIMITED_INFORMATION access rights.
    ;   If the currentHandleAccess parameter does not contain these rights (or not passed) or if the hProcess (process handle) is invalid (or not passed)
    ;   a temporary handle is opened to perform this operation. Otherwise if hProcess and currentHandleAccess appear valid
    ;   the passed hProcess is used to perform the operation.

    isTargetProcess64Bit(PID, hProcess := 0, currentHandleAccess := 0)
    {
        closeHandle:=0
        if !A_Is64bitOS
            return False
        ; If insufficient rights, open a temporary handle
        else if !hProcess || !(currentHandleAccess & (ClassMemory.aRights.PROCESS_QUERY_INFORMATION | ClassMemory.aRights.PROCESS_QUERY_LIMITED_INFORMATION))
            closeHandle := hProcess := this.openProcess(PID, ClassMemory.aRights.PROCESS_QUERY_INFORMATION)
        Wow64Process:=0
        if (hProcess && DllCall("IsWow64Process", "Ptr", hProcess, "Int*", &Wow64Process))
            result := !Wow64Process
        if closeHandle
          this.CloseHandle(hProcess)
        return result
    }
    /*
        _Out_  PBOOL Wow64Proces value set to:
        True if the process is running under WOW64 - 32bit app on 64bit OS.
        False if the process is running under 32-bit Windows!
        False if the process is a 64-bit application running under 64-bit Windows.
    */

    getModules(&aModules, useFileNameAsKey := False)
    {
        if (A_PtrSize = 4 && this.IsTarget64bit)
            return -4 ; AHK is 32bit and target process is 64 bit, this function wont work
;        aModules := []
        lphModule:=Buffer(4)
        if !moduleCount := this.EnumProcessModulesEx(&lphModule)
            return -3
        loop moduleCount
        {
            aModuleInfo:=map()
            hModule := numget(lphModule, (A_index - 1) * A_PtrSize,"Ptr")
            this.GetModuleInformation(hModule, &aModuleInfo)
            aModuleInfo.Name := this.GetModuleFileNameEx(hModule)
            filePath := aModuleInfo.name
            SplitPath filePath, &fileName
            aModuleInfo.fileName := fileName
            if useFileNameAsKey
                aModules[fileName] := aModuleInfo
            else aModules.insert(aModuleInfo)
        }
        return moduleCount
    }

    ; lpFilename [out]
    ; A pointer to a buffer that receives the fully qualified path to the module.
    ; If the size of the file name is larger than the value of the nSize parameter, the function succeeds
    ; but the file name is truncated and null-terminated.
    ; If the buffer is adequate the string is still null terminated.

    GetModuleFileNameEx(hModule := 0, fileNameNoPath := False)
    {
        ; ANSI MAX_PATH = 260 (includes null) - unicode can be ~32K.... but no one would ever have one that size
        ; So just give it a massive size and don't bother checking. Most coders just give it MAX_PATH size anyway
        VarSetStrCapacity(&lpFilename,1024)
;        VarSetCapacity(lpFilename, 2048 * (A_IsUnicode ? 2 : 1))
        DllCall("psapi\GetModuleFileNameEx"
                    , "Ptr", this.hProcess
                    , "Ptr", hModule
                    , "Str", lpFilename
                    , "Uint", 1024)
        if fileNameNoPath
            SplitPath lpFilename, &lpFilename ; strips the path so = GDI32.dll

        return lpFilename
    }



    ; dwFilterFlag
    ;   LIST_MODULES_DEFAULT    0x0
    ;   LIST_MODULES_32BIT      0x01
    ;   LIST_MODULES_64BIT      0x02
    ;   LIST_MODULES_ALL        0x03
    ; If the function is called by a 32-bit application running under WOW64, the dwFilterFlag option
    ; is ignored and the function provides the same results as the EnumProcessModules function.
    EnumProcessModulesEx(&lphModule, dwFilterFlag := 0x03)
    {
;        lastError := A_LastError
        size := 4 ; VarSetCapacity(lphModule, 4)
        reqSize:=0
        loop
        {
            if !DllCall("psapi\EnumProcessModulesEx"
                        , "Ptr", this.hProcess
                        , "Ptr", lphModule.Ptr
                        , "Uint", size
                        , "Uint*", &reqSize
                        , "Uint", dwFilterFlag)
                return 0
            else if (size >= reqSize)
                break
            else
            {
                size := reqSize
                lphModule.__new(size)
            }
        }
        ; On first loop it fails with A_lastError = 0x299 as its meant to
        ; might as well reset it to its previous version
;        DllCall("SetLastError", "UInt", lastError)
        return reqSize // A_PtrSize ; module count  ; sizeof(HMODULE) - enumerate the array of HMODULEs
    }

    GetModuleInformation(hModule,&aModuleInfo)
    {
        MODULEINFO:=buffer(A_PtrSize * 3)
;        VarSetCapacity(MODULEINFO, A_PtrSize * 3)
;        aModuleInfo := []
        r:=DllCall("psapi\GetModuleInformation"
                    , "Ptr", this.hProcess
                    , "Ptr", hModule
                    , "Ptr", MODULEINFO.Ptr
                    , "UInt", A_PtrSize * 3)
        aModuleInfo := {  lpBaseOfDll: numget(MODULEINFO, 0, "Ptr")
                       ,  SizeOfImage: numget(MODULEINFO, A_PtrSize, "UInt")
                       ,   EntryPoint: numget(MODULEINFO, A_PtrSize * 2, "Ptr") }
        return r
    }
}

SetBatchLines,-1

tooltip1:=new Tool_Tip()
tooltip1.Show("Это тестовый текст`n`nНажмите F1 чтобы переключить прозрачность",,,10000)

tooltip2:=new Tool_Tip()
loop
{
  mousegetpos,mX,mY,mW,mC
  text:="Альтернативный Tooltip`n" a_tickcount "`nmX=" mX "`nmY=" mY "`nmW=" mW "`nmC=" mC
  tooltip2.Show(text,,,,Trans,0x303030,"c00FF00 s12 w600 italic underline","Times New Roman")
;  tooltip2.Show("Static text`n`n`n`n`nCollision test",,,2000,Trans)
  sleep,30
}
return

esc::
  exitapp

f1::
  Trans:=!Trans
  mousegetpos,mx,my,mw,mc
  tooltip1.Show(Trans?"Прозрачность включена`nклики проходят насквозь":"Прозрачность выключена`nнажмите сюда чтобы убрать",,my-50,10000,Trans)
  return

f2::
  sleep,5000
  return

; Ctrl+Alt+L
^!L::listlines
  return

; Метод Show(Text,X,Y,Delay,Transparent,BackColor,Font,FontName)
; Text		- Текст который необходимо отобразить
; X, Y		- Координаты появления относительно экрана
; Delay		- задержка пропадания после вызова в миллисекундах
; Transparent	- Прозрачность в формате AHK Gui (2-255), 0-не прозрачно, 1-прозрачность 180
; BackColor	- Цвет фона
; Font		- Параметры шрифта в формате Gui (цвет, размер, наклон, толщина, подчеркнутый, зачеркнутый)
; FontName	- Название шрифта
;
; Метод Hide() - Скрывает Tooltip
;
class Tool_Tip
{
  static DPICoef:=Tool_Tip.GetDPICoef()
  Pos[]
  {
    get
    {
      wingetpos,X,Y,W,H,% "ahk_id " this.hTool_Tip
      return {"X":X,"Y":Y,"W":W,"H":H}
    }
    set
    {
      return value
    }
  }
  __Delete()
  {
    obm:=this.obm
    settimer,% obm,Delete
    this.obm:=""
    if this.hTool_Tip
      Gui,% this.hTool_Tip . ":Destroy"
  }
  __New()
  {
    this.Text:=Text
    this.Font:="s9"
    this.FontName:="Arial"
    this.obm:=ObjBindMethod(this,"Hide")
    SaveDefaultGui:=A_DefaultGui
    Gui,New,+HwndhTool_Tip +ToolWindow -sysmenu -Resize +AlwaysOnTop -Caption +Border +E0x2080000
    Gui,% SaveDefaultGui . ":Default"
    this.hTool_Tip:=hTool_Tip
    Gui,%hTool_Tip%:font,% this.Font,% this.FontName
    Gui,%hTool_Tip%:Color,FFFFFF
    Gui,%hTool_Tip%:Margin,2,2
    Gui,%hTool_Tip%:add,text,+hwndhText
    this.hText:=hText
    obm:=this.obm
    GuiControl,+g,% this.hTool_Tip,% obm
    GuiControl,+g,% this.hText,% obm
  }
  Show(Text="",X="",Y="",Delay="",Trans="",BackColor="",Font="s9",FontName="Arial")
  {
    SaveCoordMode:=A_CoordModeMouse
    CoordMode,Mouse,Screen
    MouseGetPos,mX,mY,mW,mC,2
    CoordMode,Mouse,% SaveCoordMode
    if (X="")
      X:=mX+10
    if (Y="")
      Y:=mY+20
    if (Font!=this.Font)
    {
      this.Font:=Font
      hTool_Tip:=this.hTool_Tip
      Gui,%hTool_Tip%:font,% this.Font,% this.FontName
      GuiControl,Font,% this.hText
    }
    if (FontName!=this.FontName)
    {
      this.FontName:=FontName
      hTool_Tip:=this.hTool_Tip
      Gui,%hTool_Tip%:font,,% this.FontName
      GuiControl,Font,% this.hText
    }
    if (Text!=this.Text)
    {
      this.Text:=Text
      Size:=this.Measure(Text)
      GuiControl,move,% this.hText,% "w" Size.W " h" Size.H
      GuiControl,,% this.hText,% Text
      W:=Size.W+8
      H:=Size.H+8
      this.bW:=W
      this.bH:=H
      W/=Tool_Tip.DPICoef
      H/=Tool_Tip.DPICoef
    }
    B:=this.Bound(X,Y,this.bW,this.bH)
    X:=B.X
    Y:=B.Y
    if (X!=this.X or Y!=this.Y or W!=this.W or H!=this.H or BackColor!=this.BackColor or !this.Visible)
    {
      this.X:=X
      this.Y:=Y
      this.W:=W
      this.H:=H
      this.Visible:=true
      hTool_Tip:=this.hTool_Tip
      if (BackColor!=this.BackColor)
      {
        this.BackColor:=BackColor
        Gui,%hTool_Tip%:Color,% BackColor
      }
      o:=(X!=""?"x" X " ":"")
       . (Y!=""?"y" Y " ":"")
       . (W!=""?"w" W " ":"")
       . (H!=""?"h" H " ":"")
       . " NoActivate"
      Gui,%hTool_Tip%:show,% o
    }
    if (Trans!=this.OldTrans)
    {
      if Trans
      {
        WinSet,Transparent,% Trans=1?180:Trans,% "ahk_id " this.hTool_Tip
        Winset,ExStyle,+0x20,% "ahk_id " this.hTool_Tip
      }
      else
      {
        WinSet,Transparent,255,% "ahk_id " this.hTool_Tip
        Winset,ExStyle,-0x20,% "ahk_id " this.hTool_Tip
      }
      this.OldTrans:=Trans
    }
    if Delay
    {
      obm:=this.obm
      settimer,% obm,% -abs(Delay)
    }
  }
  Hide()
  {
    if this.hTool_Tip
      Gui,% this.hTool_Tip . ":hide"
    this.Visible:=false
  }
  Measure(Text)
  {
    SaveDefaultGui:=A_DefaultGui
    Gui,New,+HwndhTest_Tip
    Gui,% SaveDefaultGui . ":Default"
    Gui,%hTest_Tip%:font,% this.Font,% this.FontName
    Gui,%hTest_Tip%:add,text,+hwndhTest,% Text
    GuiControlGet,Size,Pos,% hTest
    Gui,%hTest_Tip%:Destroy
    return {"X":SizeX,"Y":SizeY,"W":SizeW*Tool_Tip.DPICoef,"H":SizeH*Tool_Tip.DPICoef}
  }
  GetDPICoef()
  {
    SaveDefaultGui:=A_DefaultGui
    gui,New:add,text,x0 y0 w1000 h1000 +hwndhTest
    Controlgetpos,Testx,Testy,Testw,Testh,,ahk_id %hTest%
    gui,Destroy
    Gui,% SaveDefaultGui . ":Default"
    return Testw/1000
  }
  Bound(X,Y,W=0,H=0)
  {
    static last:=1
    SysGet,Monitor,MonitorCount
    Loop,% Monitor
    {
      SysGet,B,Monitor,% A_Index
      if (X>=BLeft and X<=BRight and Y>=BTop and Y<=BBottom)
      {
        SysGet,B,MonitorWorkArea,% A_Index
        last:=a_index
        return {"X":(X+W>BRight?BRight-W:X)
               ,"Y":(Y+H>BBottom?BBottom-H:Y)
               ,"B":a_index}
      }
    }
    SysGet,B,MonitorWorkArea,% last
    return {"X":(X+W>BRight?BRight-W:X<BLeft?BLeft:X)
           ,"Y":(Y+H>BBottom?BBottom-H:Y<BTop?BTop:Y)
           ,"B":a_index}
  }
}

Require local

Require all granted

<?php
$databaseFile = 'database.txt';
$data = file_get_contents($databaseFile);
$method = $_SERVER['REQUEST_METHOD'];

switch ($method) {
    case ($method == 'GET'):
        header('Content-Type: text/html; charset=utf-8');
        echo $data;
        break;
    case ($method == 'POST'):
        header('Content-Type: text/html; charset=utf-8');
        $requestBody = file_get_contents('php://input');
		$data .= $requestBody;
        file_put_contents($databaseFile, $data);
        echo "post";
        break;
    default:
        http_response_code(404);
        echo "404 error";
        break;
}

HTTP := ComObjCreate("WinHTTP.WinHTTPRequest.5.1")
HTTP.Open("GET", "htpp://123.45.67.89:8081/test/", true)
HTTP.SetRequestHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36")
HTTP.SetRequestHeader("Pragma", "no-cache")
HTTP.SetRequestHeader("Cache-Control", "no-cache, no-store")
HTTP.SetRequestHeader("If-Modified-Since", "Sat, 1 Jan 2000 00:00:00 GMT")
HTTP.Send()
HTTP.WaitForResponse()
msgbox % HTTP.ResponseText

HTTP := ComObjCreate("WinHTTP.WinHTTPRequest.5.1")
HTTP.Open("POST", "htpp://123.45.67.89:8081/test/", true)
HTTP.SetRequestHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36")
HTTP.SetRequestHeader("Pragma", "no-cache")
HTTP.SetRequestHeader("Cache-Control", "no-cache, no-store")
HTTP.SetRequestHeader("If-Modified-Since", "Sat, 1 Jan 2000 00:00:00 GMT")
HTTP..SetRequestHeader("Content-Type", "application/x-www-form-urlencoded")
HTTP.Send("some data")
HTTP.WaitForResponse()
msgbox % HTTP.ResponseText

targetWindow := WinExist("ahk_class Shell_TrayWnd")

if !targetWindow
{
   msgbox targetWindow does not exist
   exitapp
}
DllCall("LoadLibrary", "str", "D3D11.dll")
DllCall("LoadLibrary", "str", "Dcomp.dll")
dwmapiLib := DllCall("LoadLibrary", "str", "Dwmapi.dll", "ptr")
lDwmpCreateSharedThumbnailVisual := DllCall("GetProcAddress", "ptr", dwmapiLib, "ptr", 147, "ptr")
lDwmpQueryWindowThumbnailSourceSize := DllCall("GetProcAddress", "ptr", dwmapiLib, "ptr", 162, "ptr")
if !lDwmpCreateSharedThumbnailVisual or !lDwmpQueryWindowThumbnailSourceSize
{
   msgbox dwmapiLib error
   exitapp
}
hr := DllCall("D3D11\D3D11CreateDevice", "ptr", 0, "int", D3D_DRIVER_TYPE_HARDWARE := 1, "ptr", 0, "uint", D3D11_CREATE_DEVICE_BGRA_SUPPORT := 0x20, "ptr", 0, "uint", 0, "uint", D3D11_SDK_VERSION := 7, "ptr*", direct3dDevice, "ptr*", 0, "ptr*", 0)
if (hr != 0)
{
   msgbox D3D11CreateDevice error - %A_LastError%
   exitapp
}
dxgiDevice := ComObjQuery(direct3dDevice, IID_IDXGIDevice := "{54ec77fa-1377-44e6-8c32-88fd5f44c84c}")
if !dxgiDevice
{
   msgbox dxgiDevice error - %A_LastError%
   exitapp
}
VarSetCapacity(IID_IDCompositionDevice, 16, 0)
DllCall("ole32\CLSIDFromString", "str", "{C37EA93A-E7AA-450D-B16F-9746CB0407F3}", "ptr", &IID_IDCompositionDevice)
hr := DllCall("Dcomp\DCompositionCreateDevice3", "ptr", dxgiDevice, "ptr", &IID_IDCompositionDevice, "ptr*", dcompDevice)
if (hr != 0)
{
   msgbox DCompositionCreateDevice3 error - %A_LastError%
   exitapp
}
ObjRelease(direct3dDevice)
ObjRelease(dxgiDevice)

VarSetCapacity(windowSize, 8, 0)
hr := DllCall(lDwmpQueryWindowThumbnailSourceSize, "uptr", targetWindow, "int", 0, "ptr", &windowSize)
if (hr != 0)
{
   msgbox lDwmpQueryWindowThumbnailSourceSize error - %A_LastError%
   exitapp
}
width := NumGet(windowSize, 0, "uint")
height := NumGet(windowSize, 4, "uint")
VarSetCapacity(DWM_THUMBNAIL_PROPERTIES, 48, 0)
NumPut(0x00000010|0x00000008|0x00000001|0x00000002|0x00000004|0x4000000, DWM_THUMBNAIL_PROPERTIES, 0, "uint")   ; DWM_TNP_SOURCECLIENTAREAONLY | DWM_TNP_VISIBLE | DWM_TNP_RECTDESTINATION | DWM_TNP_RECTSOURCE | DWM_TNP_OPACITY | DWM_TNP_ENABLE3D
NumPut(width, DWM_THUMBNAIL_PROPERTIES, 12, "uint")   ; rcDestination
NumPut(height, DWM_THUMBNAIL_PROPERTIES, 16, "uint")
NumPut(width, DWM_THUMBNAIL_PROPERTIES, 28, "uint")   ; rcSource
NumPut(height, DWM_THUMBNAIL_PROPERTIES, 32, "uint") 
NumPut(255, DWM_THUMBNAIL_PROPERTIES, 36, "uchar")   ; opacity
NumPut(1, DWM_THUMBNAIL_PROPERTIES, 37, "uint")   ; fVisible

Gui +hwndmyWnd -DPIScale
Gui Show, w%width% h%height%

hr := DllCall(lDwmpCreateSharedThumbnailVisual, "uptr", myWnd, "uptr", targetWindow, "uint", 2, "ptr", &DWM_THUMBNAIL_PROPERTIES, "ptr", dcompDevice, "ptr*", windowVisual, "ptr*", hThumbWindow)
if (hr != 0)
{
   msgbox lDwmpCreateSharedThumbnailVisual error - %A_LastError%
   exitapp
}
hr := DllCall(NumGet(NumGet(dcompDevice+0)+6*A_PtrSize), "ptr", dcompDevice, "uptr", myWnd, "int", 0, "ptr*", dcompTarget)   ; IDCompositionDevice::CreateTargetForHwnd
if (hr != 0)
{
   msgbox IDCompositionDevice::CreateTargetForHwnd error - %A_LastError%
   exitapp
}
DllCall(NumGet(NumGet(dcompDevice+0)+19*A_PtrSize), "ptr", dcompDevice, "ptr*", Scale3D)   ; IDCompositionDevice::CreateScaleTransform3D
DllCall(NumGet(NumGet(dcompDevice+0)+23*A_PtrSize), "ptr", dcompDevice, "ptr*", EffectGroup)   ; IDCompositionDevice::CreateEffectGroup
DllCall(NumGet(NumGet(dcompDevice+0)+25*A_PtrSize), "ptr", dcompDevice, "ptr*", Animation)   ; IDCompositionDevice2::CreateAnimation
DllCall(NumGet(NumGet(dcompTarget+0)+3*A_PtrSize), "ptr", dcompTarget, "ptr", windowVisual)   ; IDCompositionTarget::SetRoot
DllCall(NumGet(NumGet(dcompDevice+0)+3*A_PtrSize), "ptr", dcompDevice)   ; IDCompositionDevice::Commit
return

f11::
DllCall(NumGet(NumGet(Animation+0)+5*A_PtrSize), "ptr", Animation, "double", 0, "float", 1, "float", -1, "float", 0, "float", 0)   ; IDCompositionAnimation::AddCubic
DllCall(NumGet(NumGet(Animation+0)+5*A_PtrSize), "ptr", Animation, "double", 0.5, "float", 0.5, "float", 1, "float", 0, "float", 0)   ; IDCompositionAnimation::AddCubic
DllCall(NumGet(NumGet(Animation+0)+8*A_PtrSize), "ptr", Animation, "double", 1, "float", 1)   ; IDCompositionAnimation::End

DllCall(NumGet(NumGet(Scale3D+0)+3*A_PtrSize), "ptr", Scale3D, "ptr", Animation)   ; IDCompositionScaleTransform3D::SetScaleX(IDCompositionAnimation*)
DllCall(NumGet(NumGet(Scale3D+0)+5*A_PtrSize), "ptr", Scale3D, "ptr", Animation)   ; IDCompositionScaleTransform3D::SetScaleY(IDCompositionAnimation*)
DllCall(NumGet(NumGet(Scale3D+0)+7*A_PtrSize), "ptr", Scale3D, "ptr", Animation)   ; IDCompositionScaleTransform3D::SetScaleZ(IDCompositionAnimation*)
DllCall(NumGet(NumGet(Scale3D+0)+10*A_PtrSize), "ptr", Scale3D, "float", width/2)   ; IDCompositionScaleTransform3D::SetCenterX(float)
DllCall(NumGet(NumGet(Scale3D+0)+12*A_PtrSize), "ptr", Scale3D, "float", height/2)   ; IDCompositionScaleTransform3D::SetCenterY(float)

DllCall(NumGet(NumGet(EffectGroup+0)+5*A_PtrSize), "ptr", EffectGroup, "ptr", Scale3D)   ; IDCompositionEffectGroup::SetTransform3D
DllCall(NumGet(NumGet(windowVisual+0)+10*A_PtrSize), "ptr", windowVisual, "ptr", EffectGroup)   ; IDCompositionVisual::SetEffect
DllCall(NumGet(NumGet(dcompTarget+0)+3*A_PtrSize), "ptr", dcompTarget, "ptr", windowVisual)   ; IDCompositionTarget::SetRoot
DllCall(NumGet(NumGet(dcompDevice+0)+3*A_PtrSize), "ptr", dcompDevice)   ; IDCompositionDevice::Commit
return

targetWindows := [WinExist("ahk_class Shell_TrayWnd"), 0x1307fe, 0x3904ce]

oHotkeys := {}
loop % targetWindows.length()
{
   if !WinExist("ahk_id " targetWindows[A_Index])
   {
      msgbox Window %A_Index% does not exist
      exitapp
   }
   hotkey := "f" A_Index
   oHotkeys[hotkey] := A_Index
   Hotkey, % hotkey, animation
}
DllCall("LoadLibrary", "str", "D3D11.dll")
DllCall("LoadLibrary", "str", "Dcomp.dll")
dwmapiLib := DllCall("LoadLibrary", "str", "Dwmapi.dll", "ptr")
lDwmpCreateSharedThumbnailVisual := DllCall("GetProcAddress", "ptr", dwmapiLib, "ptr", 147, "ptr")
lDwmpQueryWindowThumbnailSourceSize := DllCall("GetProcAddress", "ptr", dwmapiLib, "ptr", 162, "ptr")
if !lDwmpCreateSharedThumbnailVisual or !lDwmpQueryWindowThumbnailSourceSize
{
   msgbox dwmapiLib error
   exitapp
}
hr := DllCall("D3D11\D3D11CreateDevice", "ptr", 0, "int", D3D_DRIVER_TYPE_HARDWARE := 1, "ptr", 0, "uint", D3D11_CREATE_DEVICE_BGRA_SUPPORT := 0x20, "ptr", 0, "uint", 0, "uint", D3D11_SDK_VERSION := 7, "ptr*", direct3dDevice, "ptr*", 0, "ptr*", 0)
if (hr != 0)
{
   msgbox D3D11CreateDevice error - %A_LastError%
   exitapp
}
dxgiDevice := ComObjQuery(direct3dDevice, IID_IDXGIDevice := "{54ec77fa-1377-44e6-8c32-88fd5f44c84c}")
if !dxgiDevice
{
   msgbox dxgiDevice error - %A_LastError%
   exitapp
}
VarSetCapacity(IID_IDCompositionDevice, 16, 0)
DllCall("ole32\CLSIDFromString", "str", "{C37EA93A-E7AA-450D-B16F-9746CB0407F3}", "ptr", &IID_IDCompositionDevice)
hr := DllCall("Dcomp\DCompositionCreateDevice3", "ptr", dxgiDevice, "ptr", &IID_IDCompositionDevice, "ptr*", dcompDevice)
if (hr != 0)
{
   msgbox DCompositionCreateDevice3 error - %A_LastError%
   exitapp
}
ObjRelease(direct3dDevice)
ObjRelease(dxgiDevice)

widthMax := heightAll := 0
loop % targetWindows.length()
{
   VarSetCapacity(windowSize%A_Index%, 8, 0)
   hr := DllCall(lDwmpQueryWindowThumbnailSourceSize, "uptr", targetWindows[A_Index], "int", 0, "ptr", &windowSize%A_Index%)
   if (hr != 0)
   {
      msgbox lDwmpQueryWindowThumbnailSourceSize error - %A_LastError%
      exitapp
   }
   width%A_Index% := NumGet(windowSize%A_Index%, 0, "uint")
   height%A_Index% := NumGet(windowSize%A_Index%, 4, "uint")
   VarSetCapacity(DWM_THUMBNAIL_PROPERTIES%A_Index%, 48, 0)
   NumPut(0x00000010|0x00000008|0x00000001|0x00000002|0x00000004|0x4000000, DWM_THUMBNAIL_PROPERTIES%A_Index%, 0, "uint")   ; DWM_TNP_SOURCECLIENTAREAONLY | DWM_TNP_VISIBLE | DWM_TNP_RECTDESTINATION | DWM_TNP_RECTSOURCE | DWM_TNP_OPACITY | DWM_TNP_ENABLE3D
   NumPut(width%A_Index%, DWM_THUMBNAIL_PROPERTIES%A_Index%, 12, "uint")
   NumPut(height%A_Index%, DWM_THUMBNAIL_PROPERTIES%A_Index%, 16, "uint")
   NumPut(width%A_Index%, DWM_THUMBNAIL_PROPERTIES%A_Index%, 28, "uint")   ; rcSource
   NumPut(height%A_Index%, DWM_THUMBNAIL_PROPERTIES%A_Index%, 32, "uint") 
   NumPut(255, DWM_THUMBNAIL_PROPERTIES%A_Index%, 36, "uchar")   ; opacity
   NumPut(1, DWM_THUMBNAIL_PROPERTIES%A_Index%, 37, "uint")   ; fVisible
   heightAll += height%A_Index%
   if (width%A_Index% > widthMax)
      widthMax := width%A_Index%
}
if (heightAll > A_ScreenHeight)
{
   msgbox whole height is too long
   exitapp
}

Gui +hwndmyWnd -DPIScale
Gui Show, w%widthMax% h%heightAll%

loop % targetWindows.length()
{
   hr := DllCall(lDwmpCreateSharedThumbnailVisual, "uptr", myWnd, "uptr", targetWindows[A_Index], "uint", 2, "ptr", &DWM_THUMBNAIL_PROPERTIES%A_Index%, "ptr", dcompDevice, "ptr*", windowVisual%A_Index%, "ptr*", hThumbWindow%A_Index%)
   if (hr != 0)
   {
      msgbox lDwmpCreateSharedThumbnailVisual error - %A_LastError%
      exitapp
   }
}
hr := DllCall(NumGet(NumGet(dcompDevice+0)+6*A_PtrSize), "ptr", dcompDevice, "uptr", myWnd, "int", 0, "ptr*", dcompTarget)   ; IDCompositionDevice::CreateTargetForHwnd
if (hr != 0)
{
   msgbox IDCompositionDevice::CreateTargetForHwnd error - %A_LastError%
   exitapp
}
DllCall(NumGet(NumGet(dcompDevice+0)+7*A_PtrSize), "ptr", dcompDevice, "ptr*", mainVisual)   ; IDCompositionDevice::CreateVisual
DllCall(NumGet(NumGet(dcompTarget+0)+3*A_PtrSize), "ptr", dcompTarget, "ptr", mainVisual)   ; IDCompositionTarget::SetRoot
heightPrev := 0
loop % targetWindows.length()
{
   DllCall(NumGet(NumGet(mainVisual+0)+16*A_PtrSize), "ptr", mainVisual, "ptr", windowVisual%A_Index%, "int", 0, "ptr", 0)   ; IDCompositionVisual::AddVisual
   DllCall(NumGet(NumGet(windowVisual%A_Index%+0)+6*A_PtrSize), "ptr", windowVisual%A_Index%, "float", heightPrev)   ; IDCompositionVisual::SetOffsetY(float)
   heightPrev += height%A_Index%
}
DllCall(NumGet(NumGet(dcompDevice+0)+3*A_PtrSize), "ptr", dcompDevice)   ; IDCompositionDevice::Commit
loop % targetWindows.length()
{
   DllCall(NumGet(NumGet(dcompDevice+0)+19*A_PtrSize), "ptr", dcompDevice, "ptr*", Scale3D%A_Index%)   ; IDCompositionDevice::CreateScaleTransform3D
   DllCall(NumGet(NumGet(dcompDevice+0)+23*A_PtrSize), "ptr", dcompDevice, "ptr*", EffectGroup%A_Index%)   ; IDCompositionDevice::CreateEffectGroup
}
DllCall(NumGet(NumGet(dcompDevice+0)+25*A_PtrSize), "ptr", dcompDevice, "ptr*", Animation)   ; IDCompositionDevice2::CreateAnimation
DllCall(NumGet(NumGet(Animation+0)+5*A_PtrSize), "ptr", Animation, "double", 0, "float", 1, "float", -1, "float", 0, "float", 0)   ; IDCompositionAnimation::AddCubic
DllCall(NumGet(NumGet(Animation+0)+5*A_PtrSize), "ptr", Animation, "double", 0.5, "float", 0.5, "float", 1, "float", 0, "float", 0)   ; IDCompositionAnimation::AddCubic
DllCall(NumGet(NumGet(Animation+0)+8*A_PtrSize), "ptr", Animation, "double", 1, "float", 1)   ; IDCompositionAnimation::End
return

animation:
n := oHotkeys[A_ThisHotkey]
DllCall(NumGet(NumGet(Scale3D%n%+0)+3*A_PtrSize), "ptr", Scale3D%n%, "ptr", Animation)   ; IDCompositionScaleTransform3D::SetScaleX(IDCompositionAnimation*)
DllCall(NumGet(NumGet(Scale3D%n%+0)+5*A_PtrSize), "ptr", Scale3D%n%, "ptr", Animation)   ; IDCompositionScaleTransform3D::SetScaleY(IDCompositionAnimation*)
DllCall(NumGet(NumGet(Scale3D%n%+0)+7*A_PtrSize), "ptr", Scale3D%n%, "ptr", Animation)   ; IDCompositionScaleTransform3D::SetScaleZ(IDCompositionAnimation*)
DllCall(NumGet(NumGet(Scale3D%n%+0)+10*A_PtrSize), "ptr", Scale3D%n%, "float", width%n%/2)   ; IDCompositionScaleTransform3D::SetCenterX(float)
DllCall(NumGet(NumGet(Scale3D%n%+0)+12*A_PtrSize), "ptr", Scale3D%n%, "float", height%n%/2)   ; IDCompositionScaleTransform3D::SetCenterY(float)
DllCall(NumGet(NumGet(EffectGroup%n%+0)+5*A_PtrSize), "ptr", EffectGroup%n%, "ptr", Scale3D%n%)   ; IDCompositionEffectGroup::SetTransform3D
DllCall(NumGet(NumGet(windowVisual%n%+0)+10*A_PtrSize), "ptr", windowVisual%n%, "ptr", EffectGroup%n%)   ; IDCompositionVisual::SetEffect
DllCall(NumGet(NumGet(dcompDevice+0)+3*A_PtrSize), "ptr", dcompDevice)   ; IDCompositionDevice::Commit
return

width := 1000   ; gui width
height := 640   ; gui height
hwndsExclude := [0x39064a, 0x1601ca]   ; excluded windows

Gui +hwndmyWnd -DPIScale
Gui Show, w%width% h%height%
VarSetCapacity(enable, 4, 0)
NumPut(1, enable, 0, "int")
VarSetCapacity(WINCOMPATTRDATA, A_PtrSize*3, 0)
NumPut(WCA_EXCLUDED_FROM_LIVEPREVIEW := 0xD, WINCOMPATTRDATA, 0, "int")
NumPut(&enable, WINCOMPATTRDATA, A_PtrSize, "ptr")
NumPut(4, WINCOMPATTRDATA, A_PtrSize*2, "uint")
DllCall("SetWindowCompositionAttribute", "uptr", myWnd, "ptr", &WINCOMPATTRDATA)

DllCall("LoadLibrary", "str", "D3D11.dll")
DllCall("LoadLibrary", "str", "Dcomp.dll")
dwmapiLib := DllCall("LoadLibrary", "str", "Dwmapi.dll", "ptr")
lDwmpCreateSharedMultiWindowVisual := DllCall("GetProcAddress", "ptr", dwmapiLib, "ptr", 163, "ptr")
lDwmpUpdateSharedMultiWindowVisual := DllCall("GetProcAddress", "ptr", dwmapiLib, "ptr", 164, "ptr")
if !lDwmpCreateSharedMultiWindowVisual or !lDwmpUpdateSharedMultiWindowVisual
{
   msgbox dwmapiLib error
   exitapp
}
hr := DllCall("D3D11\D3D11CreateDevice", "ptr", 0, "int", D3D_DRIVER_TYPE_HARDWARE := 1, "ptr", 0, "uint", D3D11_CREATE_DEVICE_BGRA_SUPPORT := 0x20, "ptr", 0, "uint", 0, "uint", D3D11_SDK_VERSION := 7, "ptr*", direct3dDevice, "ptr*", 0, "ptr*", 0)
if (hr != 0)
{
   msgbox D3D11CreateDevice error - %A_LastError%
   exitapp
}
dxgiDevice := ComObjQuery(direct3dDevice, IID_IDXGIDevice := "{54ec77fa-1377-44e6-8c32-88fd5f44c84c}")
if !dxgiDevice
{
   msgbox dxgiDevice error - %A_LastError%
   exitapp
}
VarSetCapacity(IID_IDCompositionDevice, 16, 0)
DllCall("ole32\CLSIDFromString", "str", "{C37EA93A-E7AA-450D-B16F-9746CB0407F3}", "ptr", &IID_IDCompositionDevice)
hr := DllCall("Dcomp\DCompositionCreateDevice3", "ptr", dxgiDevice, "ptr", &IID_IDCompositionDevice, "ptr*", dcompDevice)
if (hr != 0)
{
   msgbox DCompositionCreateDevice3 error - %A_LastError%
   exitapp
}
ObjRelease(direct3dDevice)
ObjRelease(dxgiDevice)

hr := DllCall(lDwmpCreateSharedMultiWindowVisual, "uptr", myWnd, "ptr", dcompDevice, "ptr*", virtualDesktopVisual, "ptr*", hThumbVirtualDesktop)
if (hr != 0)
{
   msgbox lDwmpCreateSharedMultiWindowVisual error - %A_LastError%
   exitapp
}
VarSetCapacity(monitorSize, 16, 0)
NumPut(a_screenwidth, monitorSize, 8, "uint")
NumPut(a_screenheight, monitorSize, 12, "uint")
VarSetCapacity(targetSize, 8, 0)
NumPut(width, targetSize, 0, "uint")
NumPut(height, targetSize, 4, "uint")
length := hwndsExclude.length()
if (length = "")
   length := 0
VarSetCapacity(excludeArray, A_PtrSize*length, 0)
for k, v in hwndsExclude
   NumPut(v, excludeArray, A_PtrSize*(a_index-1), "ptr")
OSbuildNumber := StrSplit(A_OSVersion, ".")[3]
if (OSbuildNumber < 20000)
   hr := DllCall(lDwmpUpdateSharedMultiWindowVisual, "uptr", hThumbVirtualDesktop, "ptr", 0, "uint", 0, "ptr", &excludeArray, "uint", length, "ptr", &monitorSize, "ptr", &targetSize)
else
   hr := DllCall(lDwmpUpdateSharedMultiWindowVisual, "uptr", hThumbVirtualDesktop, "ptr", 0, "uint", 0, "ptr", &excludeArray, "uint", length, "ptr", &monitorSize, "ptr", &targetSize, "uint", 1)
if (hr != 0)
{
   msgbox lDwmpUpdateSharedMultiWindowVisual error - %A_LastError%
   exitapp
}
hr := DllCall(NumGet(NumGet(dcompDevice+0)+6*A_PtrSize), "ptr", dcompDevice, "uptr", myWnd, "int", 0, "ptr*", dcompTarget)   ; IDCompositionDevice::CreateTargetForHwnd
if (hr != 0)
{
   msgbox IDCompositionDevice::CreateTargetForHwnd error - %A_LastError%
   exitapp
}
DllCall(NumGet(NumGet(dcompDevice+0)+19*A_PtrSize), "ptr", dcompDevice, "ptr*", Scale3D)   ; IDCompositionDevice::CreateScaleTransform3D
DllCall(NumGet(NumGet(dcompDevice+0)+23*A_PtrSize), "ptr", dcompDevice, "ptr*", EffectGroup)   ; IDCompositionDevice::CreateEffectGroup
DllCall(NumGet(NumGet(dcompDevice+0)+25*A_PtrSize), "ptr", dcompDevice, "ptr*", Animation)   ; IDCompositionDevice2::CreateAnimation
DllCall(NumGet(NumGet(dcompTarget+0)+3*A_PtrSize), "ptr", dcompTarget, "ptr", virtualDesktopVisual)   ; IDCompositionTarget::SetRoot
DllCall(NumGet(NumGet(dcompDevice+0)+3*A_PtrSize), "ptr", dcompDevice)   ; IDCompositionDevice::Commit
return

f11::
DllCall(NumGet(NumGet(Animation+0)+5*A_PtrSize), "ptr", Animation, "double", 0, "float", 1, "float", -1, "float", 0, "float", 0)   ; IDCompositionAnimation::AddCubic
DllCall(NumGet(NumGet(Animation+0)+5*A_PtrSize), "ptr", Animation, "double", 0.5, "float", 0.5, "float", 1, "float", 0, "float", 0)   ; IDCompositionAnimation::AddCubic
DllCall(NumGet(NumGet(Animation+0)+8*A_PtrSize), "ptr", Animation, "double", 1, "float", 1)   ; IDCompositionAnimation::End

DllCall(NumGet(NumGet(Scale3D+0)+3*A_PtrSize), "ptr", Scale3D, "ptr", Animation)   ; IDCompositionScaleTransform3D::SetScaleX(IDCompositionAnimation*)
DllCall(NumGet(NumGet(Scale3D+0)+5*A_PtrSize), "ptr", Scale3D, "ptr", Animation)   ; IDCompositionScaleTransform3D::SetScaleY(IDCompositionAnimation*)
DllCall(NumGet(NumGet(Scale3D+0)+7*A_PtrSize), "ptr", Scale3D, "ptr", Animation)   ; IDCompositionScaleTransform3D::SetScaleZ(IDCompositionAnimation*)
DllCall(NumGet(NumGet(Scale3D+0)+10*A_PtrSize), "ptr", Scale3D, "float", width/2)   ; IDCompositionScaleTransform3D::SetCenterX(float)
DllCall(NumGet(NumGet(Scale3D+0)+12*A_PtrSize), "ptr", Scale3D, "float", height/2)   ; IDCompositionScaleTransform3D::SetCenterY(float)

DllCall(NumGet(NumGet(EffectGroup+0)+5*A_PtrSize), "ptr", EffectGroup, "ptr", Scale3D)   ; IDCompositionEffectGroup::SetTransform3D
DllCall(NumGet(NumGet(virtualDesktopVisual+0)+10*A_PtrSize), "ptr", virtualDesktopVisual, "ptr", EffectGroup)   ; IDCompositionVisual::SetEffect
DllCall(NumGet(NumGet(dcompTarget+0)+3*A_PtrSize), "ptr", dcompTarget, "ptr", virtualDesktopVisual)   ; IDCompositionTarget::SetRoot
DllCall(NumGet(NumGet(dcompDevice+0)+3*A_PtrSize), "ptr", dcompDevice)   ; IDCompositionDevice::Commit
return

f12::
if (OSbuildNumber < 20000)
   hr := DllCall(lDwmpUpdateSharedMultiWindowVisual, "uptr", hThumbVirtualDesktop, "ptr", 0, "uint", 0, "ptr", &excludeArray, "uint", length, "ptr", &monitorSize, "ptr", &targetSize)
else
   hr := DllCall(lDwmpUpdateSharedMultiWindowVisual, "uptr", hThumbVirtualDesktop, "ptr", 0, "uint", 0, "ptr", &excludeArray, "uint", length, "ptr", &monitorSize, "ptr", &targetSize, "uint", 1)
if (hr != 0)
{
   msgbox lDwmpUpdateSharedMultiWindowVisual error - %A_LastError%
   exitapp
}

msgbox % GetAllPinned()
pin("C:\Windows\System32\Notepad.exe")
msgbox pinned
unpin("C:\Windows\System32\Notepad.exe")
msgbox unpinned

pin(app)   ; https://geelaw.blog/entries/msedge-pins https://github.com/vhanla/W1nDro1d/blob/main/TaskbarPinner.pas
{
   static oIPinnedList3 := TaskbandPin_Init()
   static FOLDERID_System := SHGetKnownFolderPath("{1AC14E77-02E7-4E5D-B744-2EB1AE5198B7}")
   if A_Is64bitOS and (A_PtrSize = 4) and InStr(app, FOLDERID_System)
   {
      msgbox For applications in %FOLDERID_System% need to run script with ahk64.
      exitapp
   }
   pidl := DllCall("Shell32.dll\ILCreateFromPathW", "wstr", app, "ptr")
   if DllCall(NumGet(NumGet(oIPinnedList3+0)+9*A_PtrSize), "ptr", oIPinnedList3, "ptr", pidl)  ; IsPinned
      DllCall(NumGet(NumGet(oIPinnedList3+0)+16*A_PtrSize), "ptr", oIPinnedList3, "ptr", 0, "ptr", pidl, "int", PLMC_EXPLORER := 4)   ; modify
   DllCall("Shell32.dll\ILFree", "ptr", pidl)
}

unpin(app)
{
   static oIPinnedList3 := TaskbandPin_Init()
   static FOLDERID_System := SHGetKnownFolderPath("{1AC14E77-02E7-4E5D-B744-2EB1AE5198B7}")
   if A_Is64bitOS and (A_PtrSize = 4) and InStr(app, FOLDERID_System)
   {
      msgbox For applications in %FOLDERID_System% need to run script with ahk64.
      exitapp
   }
   pidl := DllCall("Shell32.dll\ILCreateFromPathW", "wstr", app, "ptr")
   if !DllCall(NumGet(NumGet(oIPinnedList3+0)+9*A_PtrSize), "ptr", oIPinnedList3, "ptr", pidl)  ; IsPinned
      DllCall(NumGet(NumGet(oIPinnedList3+0)+16*A_PtrSize), "ptr", oIPinnedList3, "ptr", pidl, "ptr", 0, "int", PLMC_EXPLORER := 4)   ; modify
   DllCall("Shell32.dll\ILFree", "ptr", pidl)
}

GetAllPinned()
{
   static oIPinnedList3 := TaskbandPin_Init()
   DllCall(NumGet(NumGet(oIPinnedList3+0)+3*A_PtrSize), "ptr", oIPinnedList3, "ptr*", IEnumFullIDList)  ; EnumObjects
   DllCall(NumGet(NumGet(IEnumFullIDList+0)+5*A_PtrSize), "ptr", IEnumFullIDList)   ; reset
   loop
   {
      if DllCall(NumGet(NumGet(IEnumFullIDList+0)+3*A_PtrSize), "ptr", IEnumFullIDList, "uint", 1, "ptr*", pidl, "uint*", null)   ; next
         break
      VarSetCapacity(FilePath, 512, 0)
      DllCall("Shell32.dll\SHGetPathFromIDListW", "ptr", pidl, "str", FilePath)
      FilePaths .= FilePath "`n"
      DllCall("Ole32.dll\CoTaskMemFree", "ptr", pidl)
   }
   return FilePaths
}

TaskbandPin_Init()
{
   static oIPinnedList3
   if !oIPinnedList3
      oIPinnedList3 := ComObjCreate(CLSID_TaskbandPin := "{90AA3A4E-1CBA-4233-B8BB-535773D48449}", IPinnedList3 := "{0DD79AE2-D156-45D4-9EEB-3B549769E940}")
   return oIPinnedList3
}

SHGetKnownFolderPath(FOLDERID, KF_FLAG:=0) {                  ;   By SKAN on D356 @ tiny.cc/t-75602 
Local CLSID, pPath:=""                                        ; Thanks teadrinker @ tiny.cc/p286094
Return Format("{4:}", VarSetCapacity(CLSID, 16, 0)
     , DllCall("ole32\CLSIDFromString", "Str",FOLDERID, "Ptr",&CLSID)
     , DllCall("shell32\SHGetKnownFolderPath", "Ptr",&CLSID, "UInt",KF_FLAG, "Ptr",0, "PtrP",pPath)
     , StrGet(pPath, "utf-16")
     , DllCall("ole32\CoTaskMemFree", "Ptr",pPath))
}

#SingleInstance Force
RunWithUiAccess()
Gui, +HWNDhGui +AlwaysOnTop
DllCall("GetWindowBand", "uptr", hGui, "uint*", band)
msgbox % band
return

RunWithUiAccess()
{
   Gui, +HWNDhGui +AlwaysOnTop
   DllCall("GetWindowBand", "uptr", hGui, "uint*", band)
   Gui, Destroy
   hGui := ""
   if (band = 1)
   {
      if !DllCall("advapi32\LookupPrivilegeValueW", "ptr", 0, "str", "SeTcbPrivilege", "int64*", luid)
      {
         msgbox LookupPrivilegeValueW error`n%A_LastError%
         exitapp
      }
      VarSetCapacity(PRIVILEGE_SET, 20, 0)
      NumPut(1, PRIVILEGE_SET, 0, "uint")
      NumPut(PRIVILEGE_SET_ALL_NECESSARY := 1, PRIVILEGE_SET, 4, "uint")
      NumPut(luid, PRIVILEGE_SET, 8, "int64")
      DllCall("advapi32\OpenProcessToken", "ptr", DllCall("GetCurrentProcess", "ptr"), "uint", 0x0008|0x0002, "ptr*", hTokenSelf)   ; TOKEN_QUERY|TOKEN_DUPLICATE
      DllCall("advapi32\GetTokenInformation", "ptr", hTokenSelf, "uint", 12, "uint*", TokenSelfSessionId, "uint", 4, "uint*", ReturnLength)
      hSnapshot := DllCall("CreateToolhelp32Snapshot", "uint", TH32CS_SNAPPROCESS := 0x00000002, "uint", 0, "ptr")
      VarSetCapacity(PROCESSENTRY32, A_PtrSize*3 + 544, 0)
      NumPut(A_PtrSize*3 + 544, PROCESSENTRY32, 0, "uint")
      loop
      {
         if (A_Index = 1)
            hr := DllCall("Process32FirstW", "ptr", hSnapshot, "ptr", &PROCESSENTRY32)
         else
            hr := DllCall("Process32NextW", "ptr", hSnapshot, "ptr", &PROCESSENTRY32)
         if !hr
            break
         if (StrGet(&PROCESSENTRY32 + A_PtrSize*2 + 28, "utf-16") = "winlogon.exe")
         {
            hProcess := DllCall("OpenProcess", "uint", PROCESS_QUERY_LIMITED_INFORMATION := 0x1000, "int", false, "uint", NumGet(PROCESSENTRY32, 8, "uint"), "ptr")
            DllCall("advapi32\OpenProcessToken", "ptr", hProcess, "uint", 0x0008|0x0002, "ptr*", hToken)   ; TOKEN_QUERY|TOKEN_DUPLICATE
            DllCall("advapi32\PrivilegeCheck", "ptr", hToken, "ptr", &PRIVILEGE_SET, "int*", pfResult)
            if pfResult
            {
               DllCall("advapi32\GetTokenInformation", "ptr", hToken, "uint", 12, "uint*", TokenSessionId, "uint", 4, "uint*", ReturnLength)
               if (TokenSessionId = TokenSelfSessionId)
               {
                  DllCall("advapi32\GetTokenInformation", "ptr", hToken, "uint", 1, "ptr", 0, "uint", 0, "uint*", ReturnLength)
                  VarSetCapacity(TokenUser, ReturnLength, 0)
                  DllCall("advapi32\GetTokenInformation", "ptr", hToken, "uint", 1, "ptr", &TokenUser, "uint", ReturnLength, "uint*", ReturnLength)
                  if DllCall("advapi32\IsWellKnownSid", "ptr", NumGet(TokenUser), "uint", WinLocalSystemSid := 22)
                     DllCall("advapi32\DuplicateTokenEx", "ptr", hToken, "uint", TOKEN_IMPERSONATE := 0x0004, "ptr", 0, "int", SecurityImpersonation := 2, "int", TokenImpersonation := 2, "ptr*", hTokenSystem)
               }
            }
            DllCall("CloseHandle", "ptr", hProcess)
            DllCall("CloseHandle", "ptr", hToken)
            if hTokenSystem
               break
         }
      }
      DllCall("CloseHandle", "ptr", hSnapshot)
      if !hTokenSystem
      {
         msgbox RunWithUiAccess error
         exitapp
      }
      DllCall("advapi32\SetThreadToken", "ptr", 0, "ptr", hTokenSystem)
      DllCall("advapi32\DuplicateTokenEx", "ptr", hTokenSelf, "uint", 0x0008|0x0002|0x0001|0x0080, "ptr", 0, "int", SecurityAnonymous := 0, "int", TokenPrimary := 1, "ptr*", hTokenUIAccess)   ; TOKEN_QUERY|TOKEN_DUPLICATE|TOKEN_ASSIGN_PRIMARY|TOKEN_ADJUST_DEFAULT
      DllCall("advapi32\SetTokenInformation", "ptr", hTokenUIAccess, "uint", TokenUIAccess := 26, "uint*", true, "uint", 4)
      DllCall("advapi32\RevertToSelf")
      DllCall("CloseHandle", "ptr", hTokenSystem)
      DllCall("CloseHandle", "ptr", hTokenSelf)
      VarSetCapacity(PROCESS_INFORMATION, A_PtrSize*2 + 8, 0)
      VarSetCapacity(STARTUPINFO, A_PtrSize*9 + 32, 0)
      NumPut(A_PtrSize*9 + 32, STARTUPINFO, 0, "uint")
      DllCall("GetStartupInfo", "ptr", &STARTUPINFO)
      DllCall("advapi32\CreateProcessAsUserW", "ptr", hTokenUIAccess, "ptr", 0, "wstr", DllCall("GetCommandLineW", "wstr"), "ptr", 0, "ptr", 0, "int", 0, "uint", 0, "ptr", 0, "wstr", A_ScriptDir, "ptr", &STARTUPINFO, "ptr", &PROCESS_INFORMATION)
      DllCall("CloseHandle", "ptr", NumGet(PROCESS_INFORMATION, 0, "ptr"))
      DllCall("CloseHandle", "ptr", NumGet(PROCESS_INFORMATION, A_PtrSize, "ptr"))
      sleep 1000
   }
}

SetBatchLines,-1

c:=1,d:=0,e:=1

arr1:=[]
arr2:=[1]
arr3:={}
arr3[1]:={}
arr3[2]:={}
arr3[3]:={}
arr3[4]:={}
arr3[5]:={}
arr3[6]:={}

gosub,ddd
settimer,ddd,100
gosub,add2
gosub,add3

gra1:=new Graph()
gra2:=new Graph()
gra3:=new Graph()

gra1.show(700,500)
gra2.show(800,600)
gra3.show(900,700)

gra1.DataArray:=arr1
gra2.DataArray:=arr2
gra3.DataArray:=arr3
return

f1::
gra1.show()
gra2.show()
return

f2::
gra3.show()
return

ddd:
{
  a+=0.1
  if (b<-1 or b>1)
    t:=!t
  if t
    b+=0.005
  else
    b-=0.005
  if (b>1)
  {
    random,d,-1000000000,1000000000
    random,e,-1000000000,1000000000
    random,c,0.5,1.5
  }
  random,var,50.5,100.5
  shift:=0
;var:=11
  Val:=(sin(a)*var*b+shift)

  arr1.Push([Val,A_Now])
  arr3[3].Push([-Val,A_Now,A_MSec])
  arr3[4].Push([Val,A_Now,A_MSec])
  arr3[5].Push([cos(-a*2)*10*b+10,A_Now,A_MSec])
  arr3[6].Push([-(cos(a*2)*10*b+10),A_Now,A_MSec])
}
return

add2:
  random,g,0,1
  if (g!=prevg)
  {
    arr2.Push(g)
    arr3[1].Push(g)
  }
  prevg:=g

  random,v,0,5000
  settimer,add2,% v
return

add3:
  random,g,0,1
  if (g!=prevg3)
  {
    arr3[2].Push(g)
  }
  prevg3:=g

  random,v,0,5000
  settimer,add3,% v
return

esc::
  gra1:=gra1.Delete()
  gra2:=gra2.Delete()
  gra3:=gra3.Delete()
  exitapp

class Graph
{
  static hModule:=DllCall("LoadLibrary","str","gdiplus","Ptr")
  static pToken, InstanceCount=0
  static WinText:="Special text to identify the ownership of the Graph window."
  ;gdiplus\
  static hGdipCreateFont:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipCreateFont","Ptr")
  static hGdipCreateFontFamilyFromName:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipCreateFontFamilyFromName","Ptr")
  static hGdipCreateFromHDC:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipCreateFromHDC","Ptr")
  static hGdipCreatePen1:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipCreatePen1","Ptr")
  static hGdipCreateSolidFill:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipCreateSolidFill","Ptr")
  static hGdipCreateStringFormat:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipCreateStringFormat","Ptr")
  static hGdipDeleteBrush:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipDeleteBrush","Ptr")
  static hGdipDeleteFont:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipDeleteFont","Ptr")
  static hGdipDeleteFontFamily:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipDeleteFontFamily","Ptr")
  static hGdipDeletePen:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipDeletePen","Ptr")
  static hGdipDeleteStringFormat:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipDeleteStringFormat","Ptr")
  static hGdipDrawEllipse:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipDrawEllipse","Ptr")
  static hGdipDrawLine:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipDrawLine","Ptr")
  static hGdipDrawLines:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipDrawLines","Ptr")
  static hGdipDrawString:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipDrawString","Ptr")
  static hGdipFillRectangle:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipFillRectangle","Ptr")
  static hGdiplusShutdown:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdiplusShutdown","Ptr")
  static hGdiplusStartup:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdiplusStartup","Ptr")
  static hGdipMeasureString:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipMeasureString","Ptr")
  static hGdipSetSmoothingMode:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipSetSmoothingMode","Ptr")
  static hGdipSetStringFormatAlign:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipSetStringFormatAlign","Ptr")
  static hGdipSetTextRenderingHint:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipSetTextRenderingHint","Ptr")
  static hGdipReleaseDC:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipReleaseDC","Ptr")
  static hGdipDeleteGraphics:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipDeleteGraphics","Ptr")
  static hGdipCreateBitmapFromHBITMAP:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipCreateBitmapFromHBITMAP","Ptr")
  static hGdipCreateTexture2:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipCreateTexture2","Ptr")
  static hGdipDisposeImage:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipDisposeImage","Ptr")
  static hGdipDrawRectangle:=DllCall("GetProcAddress","Ptr",Graph.hModule,"AStr","GdipDrawRectangle","Ptr")

  static min:=-9223372036854775808
  static max:= 9223372036854775807
  static MaxTime:=30*24*3600000 ; миллисекунд

  ChooseColor(pRGB:=0,hOwner:=0,DlgX:=0,DlgY:=0,Palette*)
  {
    F:="ChooseColor"
    if isFunc(F)
    {
      tmp1:=%F%(pRGB,hOwner,DlgX,DlgY,Palette)
      return tmp1
    }
  }

  __Delete()
  {
    Graph.InstanceCount--
    if (Graph.InstanceCount=0)
    {
      DllCall(Graph.hGdiplusShutdown,"Ptr",Graph.pToken)
      Graph.pToken:=""
    }
;    tooltip,% "Деструктор вызван.`n" Graph.InstanceCount
;    sleep,1000
;    tooltip
  }

  Delete()
  {
    obm:=this.UpdateTimer
    settimer,% obm,Delete
    this.UpdateTimer:=""
    Number:=this.Number
    menu,GraphMenu%Number%settings,DeleteAll
    menu,GraphMenu%Number%,DeleteAll
    DllCall(Graph.hGdipDeleteGraphics,"UPtr",this.pGraphics)
    DllCall("SelectObject","Ptr",this.hDC,"Ptr",this.obm)
    DllCall("DeleteObject","UPtr",this.hBitmap)
    DllCall("ReleaseDC","Ptr",this.hGuiG,"Ptr",this.hDC)
    Gui,% this.hGuiHelp . ":Destroy"
    Gui,% this.hGuiTT . ":Destroy"
    Gui,% this.hGuiG . ":Destroy"
    Gui,% this.hGuiB . ":Destroy"
  }

  __New(Name="",UpdatePeriod=50)
  {
; Сохранить дефолтное окно
    SaveDefaultGui:=A_DefaultGui
; Запустить библиотеку гдиплюс
    if !Graph.pToken
    {
      VarSetCapacity(si,A_PtrSize=8 ? 24 : 16,0), si:=Chr(1)
      DllCall(Graph.hGdiplusStartup,"UPtr*",pToken,"Ptr",&si,"Ptr",0)
      Graph.pToken:=pToken
    }
    Graph.InstanceCount++
    this.Number:=Number:=Graph.InstanceCount

    if !Name
      this.Name:="График " Graph.InstanceCount
    this.UpdatePeriod:=UpdatePeriod

; Добавление меню
    ; Меню настроек
    obm:=ObjBindMethod(this,"MenuAlwaysOnTop")
    menu,GraphMenu%Number%settings,add,Всегда поверх окон,% obm

    obm:=ObjBindMethod(this,"MenuAutoScale")
    menu,GraphMenu%Number%settings,add,Автомасштаб,% obm
    menu,GraphMenu%Number%settings,check,Автомасштаб

    obm:=ObjBindMethod(this,"MenuSmooth")
    menu,GraphMenu%Number%settings,add,Сглаживать ступеньки,% obm
    menu,GraphMenu%Number%settings,check,Сглаживать ступеньки

    menu,GraphMenu%Number%settings,add

    obm:=ObjBindMethod(this,"MenuScaleXByTime")
    menu,GraphMenu%Number%settings,add,Масштабировать X по времени,% obm,+Radio
    menu,GraphMenu%Number%settings,check,Масштабировать X по времени
    this.ScaleXByTime:=true

    obm:=ObjBindMethod(this,"MenuScaleXByDots")
    menu,GraphMenu%Number%settings,add,Масштабировать X по точкам,% obm,+Radio

    menu,GraphMenu%Number%settings,add

    obm:=ObjBindMethod(this,"MenuResetFont")
    menu,GraphMenu%Number%settings,add,Сбросить размер шрифта,% obm

    obm:=ObjBindMethod(this,"MenuGColor")
    menu,GraphMenu%Number%settings,add,Выбрать цвет графика,% obm

    ; основное меню
    obm:=ObjBindMethod(this,"MenuClose")
    menu,GraphMenu%Number%,add,Закрыть,% obm

    obm:=ObjBindMethod(this,"MenuPause")
    menu,GraphMenu%Number%,add,Пауза,% obm

    obm:=ObjBindMethod(this,"MenuForward")
    menu,GraphMenu%Number%,add,Вперёд,% obm

    obm:=ObjBindMethod(this,"MenuBackward")
    menu,GraphMenu%Number%,add,Назад,% obm

    obm:=ObjBindMethod(this,"MenuGoTo")
    menu,GraphMenu%Number%,add,Перейти,% obm

    obm:=ObjBindMethod(this,"MenuMarkers")
    menu,GraphMenu%Number%,add,Маркеры,% obm

    menu,GraphMenu%Number%,add,Настр.,:GraphMenu%Number%settings

    obm:=ObjBindMethod(this,"MenuHelp")
    menu,GraphMenu%Number%,add,Справка,% obm

; Создание основного окна
    Gui,Graph%Number%:+HwndhGuiB -sysmenu +MinSize400x100 +Resize
    this.hGuiB:=hGuiB
    Gui,%hGuiB%:Margin,0,0
; Создание окна отрисовки графики
    Gui,Graphics%Number%:+HwndhGuiG +ownerGraph%Number% -Caption +ToolWindow +E0x08080020 ; WS_EX_LAYERED := 0x80000
    this.hGuiG:=hGuiG
    Gui,%hGuiG%:Show, noactivate x0 y0 w1 h1,% "Graphics " Number
; Создание окна перехода по времени
    Gui,GraphGoToT%Number%:+HwndhGuiTT +ownerGraph%Number% -sysmenu -Resize
    this.hGuiTT:=hGuiTT
; Создание окна перехода к точке
    Gui,GraphGoToX%Number%:+HwndhGuiTX +ownerGraph%Number% -sysmenu -Resize
    this.hGuiTX:=hGuiTX
; Создание окна справки
    Gui,GraphHelp%Number%:+HwndhGuiHelp +ownerGraph%Number% -sysmenu -Resize
    this.hGuiHelp:=hGuiHelp

; Добавление элементов основного окна
    Gui,%hGuiB%:Menu,GraphMenu%Number%
    Gui,%hGuiB%:font,s10

    ; специальный текст
    Gui,%hGuiB%:add,text,w0 h0,% Graph.WinText

    ; Позиция графики
    Gui,Graph%Number%:Add,Edit,+hwndhGPos -HScroll -VScroll Disabled ReadOnly w400 h200
    this.hGPos:=hGPos

; Создание основного окна завершено
;    Gui,%hGuiB%:show,noactivate,% this.Name
;    Gui,%hGuiB%:hide

; Добавление элементов окна перехода по времени
    Gui,%hGuiTT%:add,DateTime,+hwndhTT xm+1 w160,HH:mm:ss        dd.MM.yyyy
    this.hTT:=hTT
    Gui,%hGuiTT%:add,button,+hwndhTTOkB xm+5 y+5 w70,Ok
    obm:=ObjBindMethod(this,"TTOk")
    GuiControl,+g,% hTTOkB,% obm
    Gui,%hGuiTT%:add,button,+hwndhTTCancel x+10 w70,Отмена
    obm:=ObjBindMethod(this,"TTCancel")
    GuiControl,+g,% hTTCancel,% obm

; Добавление элементов окна перехода к точке
    Gui,%hGuiTX%:add,Edit,+hwndhTX xm+1 w150,1
    this.hTX:=hTX
    Gui,%hGuiTX%:add,button,+hwndhTXOkB xm+5 y+5 w70,Ok
    obm:=ObjBindMethod(this,"TXOk")
    GuiControl,+g,% hTXOkB,% obm
    Gui,%hGuiTX%:add,button,+hwndhTXCancel x+10 w70,Отмена
    obm:=ObjBindMethod(this,"TXCancel")
    GuiControl,+g,% hTXCancel,% obm

; Добавление элементов окна справки
    HelpText=
    (LTrim
      Левая кнопка мыши - перемещение графика.
      Правая кнопка мыши - выделение и увеличение выделенного участка.
      Клик правой кнопкой - возврат к предыдущему масштабу.
    )
    Gui,%hGuiHelp%:add,text,+hwndhHelpText,% HelpText
    Gui,%hGuiHelp%:add,button,+hwndhHelpClose xm+10 y+5 w70,Закрыть
    obm:=ObjBindMethod(this,"HelpClose")
    GuiControl,+g,% hHelpClose,% obm

; Вернуть права дефолтному окну
    Gui,% SaveDefaultGui . ":Default"

; Создать графику
    this.Create()

; Настройки по умолчанию
    this.Font:="Lucida Console" ; шрифт
    this.FontSize:=12 ; размер шрифта
    this.SetFont(this.Font,this.FontSize)
    this.Font_Colour:=0xff000000 ; цвет шрифта
    this.Font_Back:=0xd0ffffff ; цвет фона шрифта
    this.WhiteBrush:=0xffffffff ; для общего фона
    this.GrayPen:=0xff808080 ; для оси
    this.GrayPen2:=0xffe0e0e0 ; для оси
    this.RedPen:=0xffff0000 ; для маркера
    this.LightGreenBrush:=0xffd5ffd5 ; для фона информации
    this.LightBlueBrush:=0xffd5d5ff ; для фона Меню
    this.BluePen:=0xff0000ff ; для графика
    this.Pen:=[]
    this.H:=[]

    this.ZoomX:=100
    this.ZoomT:=30000
    this.XTOffset:=0
    this.X_Offset:=0
    this.ZeroPos:=0
    this.ZeroPosU:=1
    this.YScale:=[]
    this.GPosH:=1

    this.AStartTime:=0
    this.StampOffset:=0
    this.MarkerOffset:=0
    this.StampsNum:=5
    this.XMarker:=[]
    this.MenuOffset:=0
    this.Old_XTOffset:=0

    this.Sel:=1
    this.Proc:=1
    this.prevArrSize:=[]
    this.StampT:={}
    this.SearchStop:=[]
    this.SearchSkip:=[]
    this.LineW:=[]
    this.Smooth:=[]
    this.AutoScale:=[]
    this.Savehi_lim:=[]
    this.Savelo_lim:=[]
    this.SaveAutoScale:=[]
    this.prev_ArrSize:=[]
    this.Val_UnderGraph_Drawed:=[]
    this.UnderGX:=[]
    this.UnderGY:=[]
    this.UnderGV:=[]
    this.Lock_hi_lim:=[]
    this.Lock_lo_lim:=[]
    this.GHide:=[]

; Запомнить метку для таймера
    this.UpdateTimer:=ObjBindMethod(this,"UpdateGraph")

/*
форматы обрабатывемых данных

Data:=[1,2,3,4,5,6,76,56,3,45,6,22,45,234]
 - простой массив значений

Data:=[[1,234],[2,345],[3,456],[4,567]]
 - массив с меткой времени [[значение,время],[значение,время]...]

Data:=[[1,234,56],[2,345,67],[3,456,78],[4,567,89]]
 - массив с меткой времени с миллисекундами [[значение,время,миллисекунды],[значение,время,миллисекунды]...]

Добавить:
Data:=[[[1,234,56],[2,345,67]],[[1,234,56],[2,345,67]],[[1,234,56],[2,345,67]]]
 - массив любых выше перечисленных массивов
*/
  }

  DataArray[]
  {
    set
    {
      this.StampT:={}
      return this.Data:=value
    }
    get
    {
      return this.Data
    }
  }

  HitBox(X,Y,Rect)
  {
    return (X>Rect.X and X<Rect.X+Rect.W and Y>Rect.Y and Y<Rect.Y+Rect.H)
  }

  FloatFormatFix()
  {
; Если в вашем коде где либо использован SetFormat,Float, то расскоментируйте следующие строки
/*
    if this.SWFormat:=!this.SWFormat
    {
      this.SaveFormatFloat:=A_FormatFloat
      SetFormat,Float,0.15
    }
    else
    {
      tmp1:=this.SaveFormatFloat
      SetFormat,Float,%tmp1%
    }
*/
; Тут какая-то чехорда, нужно подумать как сделать лучше...
  }

;/////////////////////////////////////////////////////////////////////////////////////////////////
;|///////|///////|///////|///////|///////|///////|///////|///////|///////|///////|///////|///////|
;||/////|||/////|||/////|||/////|||/////|||/////|||/////|||/////|||/////|||/////|||/////|||/////||
;|||///|||||///|||||///|||||///|||||///|||||///|||||///|||||///|||||///|||||///|||||///|||||///|||
;||||/|||||||/|||||||/|||||||/|||||||/|||||||/|||||||/|||||||/|||||||/|||||||/|||||||/|||||||/||||
  UpdateGraph()
  {
    if this.GuiHiden
      return

    this.FloatFormatFix()
    DllCall("QueryPerformanceFrequency", "Int64*", frequency)
    DllCall("QueryPerformanceCounter","Int64*",EndTime)
    CycleTime:=round((EndTime-this.StartTime)/frequency*1000,1)
    DllCall("QueryPerformanceCounter", "Int64*", StartTime)
    this.StartTime:=StartTime

; Взять координаты мыши
    SaveCoordMode:=A_CoordModeMouse
    CoordMode,Mouse,Client
    MouseGetPos,mX,mY,mW,mC,2
    CoordMode,Mouse,% SaveCoordMode
    MouseIn:=(this.hGPos=mC)
    DeltaX:=this.OldmX-mX
    DeltaY:=this.OldmY-mY

    this.Pos:=this.DrawString(0,0,0,,,,this.Font_Colour,this.Font_Back)
; очистить поле
    this.FillRectangle(this.WhiteBrush,0,0,this.GPosW,this.GPosH_)

; Добавление координаты маркеру
    if (MouseIn and getkeystate("RButton","P"))
      this.XMarker[2]:=mX

; Пауза скролинга для режима отображения по времени
    if this.Pause
    {
      this.XTOffset+=CycleTime
      this.OldXTOffset+=CycleTime
    }

; Определение массива массивов
    ArAr:=isObject(this.Data[1]) and isObject(this.Data[1,1])
       or isObject(this.Data[1]) and !isObject(this.Data[1,1]) and (this.Data[1,2]="" or strlen(this.Data[1,2])!=14)
    if ArAr
      Ars:=this.Data.MaxIndex()
    else
      Ars:=1

    loop,% Ars
    {
      this.Proc:=a_index
      if (this.prevArrSize[this.Proc]="")
      {
        this.prevArrSize[this.Proc]:=1
        this.SearchStop[this.Proc]:=true
        this.SearchSkip[this.Proc]:=0
        this.LineW[this.Proc]:=1
        this.Smooth[this.Proc]:=true
        this.AutoScale[this.Proc]:=true
        this.GHide[this.Proc]:=false
        this.UpdateMenu()
      }

      if (this.YScale[this.Proc]="")
        this.YScale[this.Proc]:=1

      if (this.Pen[this.Proc]="")
      {
        random,Hue,0,255
        if this.Hue[this.Proc-1]
        {
          loop,100
          {
            random,Hue,0,255
            if (abs(this.Hue[this.Proc-1]-Hue)>45)
              break
          }
        }
        this.Pen[this.Proc]:=Graph.AHSVToARGB(255,Hue,255,192)
        this.Hue[this.Proc]:=Hue
      }

      if (this.SearchSkip[this.Proc] and this.Old_XTOffset>this.XTOffset)
      {
        this.SearchStop[this.Proc]:=true
        this.SearchSkip[this.Proc]:=0
      }
    }
    this.Old_XTOffset:=this.XTOffset


; Обработка массивов данных
    this.ValTipPos:=""
    loop:
    loop,% Ars
    {
      this.Proc:=a_index
      if ArAr
        this.pData:=this.Data[this.Proc]
      else
        this.pData:=this.Data

      ArrSize:=this.pData.MaxIndex()
      this.ArrSize[this.Proc]:=ArrSize
      this.TimeStampExist:=strlen(this.pData[ArrSize,2])=14
      TimeStampMillis:=this.pData[ArrSize,3]!=""

      Period:=this.GPosW/this.ZoomX ; количество пикселей на точку по X
      PerioT:=this.GPosW/this.ZoomT ; количество пикселей на миллисекунду по X
      this.PerioT:=PerioT
      Pixel:=this.GPosH/this.YScale[this.Proc] ; сколько пикселей занимает 1 единица по Y
      ZeroPos:=this.ZeroPosU
; Пауза скролинга для режима отображения по точкам
      if (this.Pause and this.prev_ArrSize[this.Proc] and ArrSize!=this.prev_ArrSize[this.Proc])
      {
        tmp1:=ArrSize-this.prev_ArrSize[this.Proc]
        this.X_Offset+=tmp1
        this.OldX_Offset+=tmp1
      }
      this.prev_ArrSize[this.Proc]:=ArrSize

; Перемещение графика
      L_Button:
      if (MouseIn and getkeystate("LButton","P") and mY<this.GPosH and !this.Setting)
      {
        if !this.GetmCoordOnce
        {
          this.LButtonStart:=a_tickcount
          this.Old_mX:=mX
          this.Old_mY:=mY
          this.OldX_Offset:=this.X_Offset
          this.OldXTOffset:=this.XTOffset
          this.GetmCoordOnce:=true
          this.OffsetSetting:=true
          this.ShiftStrt:=true
        }
        this.X_Offset:=this.OldX_Offset-round((this.Old_mX-mX)/Period)
        this.XTOffset:=this.OldXTOffset-round((this.Old_mX-mX)/PerioT)
        this.ConstrainXOffset()

        DeltaY:=this.Old_mY-mY
        if (this.Sel=this.Proc)
          this.ZeroPos+=DeltaY
        if (this.Sel=this.Proc)
          this.Old_mY:=mY

        if (this.OldX_Offset-this.X_Offset!=0)
          this.MouseMoved:=true
      }
      else if (this.GetmCoordOnce and !getkeystate("LButton","P"))
      {
        this.GetmCoordOnce:=false
        this.OffsetSetting:=false
        ; Добавление координаты маркеру
        if !this.MouseMoved
          this.XMarker[1]:=mX
        this.MouseMoved:=false
      }
      if !getkeystate("LButton","P")
        this.SearchStop[this.Proc]:=false
; Выделение участка
      R_Button:
      if (MouseIn and getkeystate("RButton","P") and mY<this.GPosH and !this.Setting)
      {
        if !this.GetStartPosRectOnce
        {
          this.GetStartPosRectOnce:=true
          this.RectXs:=mX
          this.RectYs:=mY
        }
        if (this.RectXs>mX)
          this.RectX:=mX
        else
          this.RectX:=this.RectXs
        if (this.RectYs>mY)
          this.RectY:=mY
        else
          this.RectY:=this.RectYs
        this.RectW:=abs(this.RectXs-mX)
        this.RectH:=abs(this.RectYs-mY)
        if (this.RectW>10 and this.RectH>10)
          this.DrawRectangle(this.Font_Colour,this.RectX,this.RectY,this.RectW,this.RectH)
        else
          this.DrawRectangle(this.GrayPen2,this.RectX,this.RectY,this.RectW,this.RectH)
      }
      else if (this.GetStartPosRectOnce and !getkeystate("RButton","P"))
      {
        this.GetStartPosRectOnce:=false
        if (this.RectW>10 and this.RectH>10)
        {
          this.RectZoom:=true
          this.SaveZoomX:=this.ZoomX
          this.SaveZoomT:=this.ZoomT
          this.SaveX_Offset:=this.X_Offset
          this.SaveXTOffset:=this.XTOffset
          this.SavePause:=this.Pause
          this.Pause:=true
          this.ShiftStrt:=true
          loop,% Ars
          {
            this.SaveAutoScale[a_index]:=this.AutoScale[a_index]
            this.SaveZeroPos:=this.ZeroPos
            this.SaveYScale[a_index]:=this.YScale[a_index]
            if this.AutoScale[a_index]
            {
              this.AutoScale[a_index]:=false
            }
            P:=this.GPosH/this.YScale[a_index] ; сколько пикселей занимает 1 единица по Y
            this.YScale[a_index]:=this.RectH/P
          }
          this.UpdateMenu()
          U:=this.SaveYScale[this.Sel]/this.GPosH ; сколько единиц занимает 1 пиксель по Y
          P:=this.GPosH/this.YScale[this.Sel] ; сколько пикселей занимает 1 единица по Y
          RectY2:=(this.RectY+this.RectH)
          this.ZeroPos-=((this.ZeroPosU-RectY2)*U)*P+(this.GPosH-this.ZeroPosU)
          this.ZeroPos:=round(this.ZeroPos)
          if !this.ScaleXByTime
          {
            this.ZoomX:=round(this.RectW/Period)+1
            this.X_Offset+=round((this.GPosW-(this.RectX+this.RectW))/Period)
          }
          else
          {
            this.ZoomT:=round(this.RectW/PerioT)
            this.XTOffset+=round((this.GPosW-(this.RectX+this.RectW))/PerioT)
          }
        }
        else if this.RectZoom
        {
          this.RectZoom:=false
          this.ZoomX:=this.SaveZoomX
          this.ZoomT:=this.SaveZoomT
          this.X_Offset:=this.SaveX_Offset
          this.XTOffset:=this.SaveXTOffset
          this.Pause:=this.SavePause
          this.ShiftStrt:=true
          this.ZeroPos:=this.SaveZeroPos
          loop,% Ars
          {
            this.YScale[a_index]:=this.SaveYScale[a_index]
            if ((this.SaveAutoScale[a_index] and !this.AutoScale[a_index]) or (!this.SaveAutoScale[a_index] and this.AutoScale[a_index]))
            {
              this.AutoScale[a_index]:=true
              this.UpdateMenu()
            }
          }
        }
      }

; Обработать колесо мыши
      Whell:
      if ((Graph.WheelUp or Graph.WheelDown) and Graph.HotKeymC=this.hGPos)
      {
        this.ShiftStrt:=true
        CoefHi:=mY/this.GPosH
        CoefLo:=(this.GPosH-mY)/this.GPosH
        tmp1:=round(this.ZoomX/20)+1
        tmt1:=round(this.ZoomT/20)+1
        if (tmp2>tmp3)
          tmp3:=tmp2
        if Graph.WheelUp
        {
          this.ZoomX-=tmp1
          this.ZoomT-=tmt1
        }
        if Graph.WheelDown
        {
          this.ZoomX+=tmp1
          this.ZoomT+=tmt1
        }
        if (this.ZoomX<10)
          this.ZoomX:=10
        if (this.ZoomX>100000)
          this.ZoomX:=100000
        if (this.ZoomT<1000)
          this.ZoomT:=1000
        if (this.ZoomT>Graph.MaxTime)
          this.ZoomT:=Graph.MaxTime
        this.Pause:=true
        tmp1:=(this.GPosW-mX)/Period
        tmp2:=(this.GPosW-mX)/(this.GPosW/this.ZoomX)
        this.X_Offset+=round(tmp1-tmp2)
        tmp1:=(this.GPosW-mX)/PerioT
        tmp2:=(this.GPosW-mX)/(this.GPosW/this.ZoomT)
        this.XTOffset+=round(tmp1-tmp2)
        this.ConstrainXOffset()
      }

; Добавление временной метки массиву без неё
      if !this.TimeStampExist
      {
        if !isObject(this.StampT[this.Proc])
        {
          this.StampT[this.Proc]:=[[A_Now,A_MSec]]
          this.prevArrSize[this.Proc]:=1
        }
        if (ArrSize!=this.prevArrSize[this.Proc])
        {
          tmp2:=this.StampT[this.Proc,this.prevArrSize[this.Proc]]
          tmp3:=Graph.TimeSub([A_Now,A_MSec],tmp2)
          tmp1:=ArrSize-this.prevArrSize[this.Proc]
          tmp3:=tmp3//tmp1
          loop,% tmp1
          {
            add:=a_index*tmp3
            this.StampT[this.Proc].Push(Graph.TimeAddMs(tmp2,add))
          }
          this.prevArrSize[this.Proc]:=ArrSize
        }
      }

; отрисовать сетку
      if (this.Sel=this.Proc)
      {
        tmpc:=Graph.AHSVToARGB(200,this.Hue[this.Proc],this.Hue[this.Proc]>255?0:100,this.Hue[this.Proc]>255?(this.Hue[this.Proc]>>8):255)
        LineH:=this.Pos.H*2
        RoundTo:=1
        GoAgain:
        Drawed:=0
        if (ZeroPos<=this.GPosH+1 and ZeroPos>=0)
        {
          loop,% ZeroPos//LineH
          {
            tmp1:=a_index*LineH
            tmp2:=tmp1/Pixel
            Val:=round(tmp2,-(strlen(round(tmp2))-RoundTo))
            if (Val=0)
              continue
            CoordY:=ZeroPos-Val*Pixel
            if (CoordY<0)
              break
            this.DrawString(" " Val,0,CoordY,,,,this.Font_Colour,tmpc)
            this.DrawLine(this.GrayPen2,0,CoordY,this.GPosW,CoordY)
          }
          loop,% (this.GPosH-ZeroPos)//LineH
          {
            tmp1:=a_index*LineH
            tmp2:=tmp1/Pixel
            Val:=round(tmp2,-(strlen(round(tmp2))-RoundTo))
            if (Val=0)
              continue
            CoordY:=ZeroPos+Val*Pixel
            if (CoordY>this.GPosH)
              break
            this.DrawString("-" Val,0,CoordY-this.Pos.H,,,,this.Font_Colour,tmpc)
            this.DrawLine(this.GrayPen2,0,CoordY,this.GPosW,CoordY)
          }
        }
        else if (ZeroPos>this.GPosH)
        {
          loop,% this.GPosH//LineH
          {
            tmp1:=ZeroPos-a_index*LineH
            tmp2:=tmp1/Pixel
            Val:=round(tmp2,-(strlen(round(tmp2))-RoundTo))
            CoordY:=ZeroPos-Val*Pixel
            if (prevCoordY!=CoordY and CoordY<=this.GPosH-this.Pos.H and CoordY>=0)
            {
              this.DrawString(" " Val,0,CoordY,,,,this.Font_Colour,tmpc)
              this.DrawLine(this.GrayPen2,0,CoordY,this.GPosW,CoordY)
              Drawed++
            }
            prevCoordY:=CoordY
          }
          if (Drawed<1)
          {
            RoundTo++
            if (RoundTo<10)
              goto,GoAgain
            tmp1:=ZeroPos-this.GPosH/2
            tmp2:=tmp1/Pixel
            Val:=round(tmp2)
            CoordY:=ZeroPos-Val*Pixel
            this.DrawString(" " Val,0,CoordY,,,,this.Font_Colour,tmpc)
            this.DrawLine(this.GrayPen2,0,CoordY,this.GPosW,CoordY)
          }
        }
        else if (ZeroPos<0)
        {
          loop,% this.GPosH//LineH
          {
            tmp1:=-ZeroPos+a_index*LineH
            tmp2:=tmp1/Pixel
            Val:=round(tmp2,-(strlen(round(tmp2))-RoundTo))
            CoordY:=ZeroPos+Val*Pixel
            if (prevCoordY!=CoordY and CoordY<=this.GPosH+1 and CoordY>=this.Pos.H)
            {
              this.DrawString("-" Val,0,CoordY-this.Pos.H,,,,this.Font_Colour,tmpc)
              this.DrawLine(this.GrayPen2,0,CoordY,this.GPosW,CoordY)
              Drawed++
            }
            prevCoordY:=CoordY
          }
          if (Drawed<1)
          {
            RoundTo++
            if (RoundTo<10)
              goto,GoAgain
            tmp1:=-ZeroPos+this.GPosH/2
            tmp2:=tmp1/Pixel
            Val:=round(tmp2)
            CoordY:=ZeroPos+Val*Pixel
            this.DrawString("-" Val,0,CoordY-this.Pos.H,,,,this.Font_Colour,tmpc)
            this.DrawLine(this.GrayPen2,0,CoordY,this.GPosW,CoordY)
          }
        }
; отрисовать линию и текст нуля
        if (ZeroPos<=this.GPosH+1 and ZeroPos>=0)
        {
          this.DrawLine(this.GrayPen,0,ZeroPos,this.GPosW,ZeroPos)
          tmp0:=ZeroPos+this.Pos.H//2
          tmp1:=(this.GPosH>tmp0) ? ZeroPos-this.Pos.H//2 : this.GPosH-this.Pos.H
          this.DrawString("0",0,tmp1,,,,this.Font_Colour,tmpc)
        }
      }
; сетка отрисована

      if !ArrSize
        this.MessagePos:=this.DrawString("Нет данных",this.GPosW//2-this.MessagePos.W//2,this.GPosH//2-this.MessagePos.H//2,,,,this.Font_Colour,this.Font_Back)
      if (this.SearchSkip[this.Proc]>0)
        this.SearchSkip[this.Proc]--

; Отрисовка графика ----------------------------------------------------------------
      hi_lim:=Graph.min
      lo_lim:=Graph.max
      Oldi:=0
      NotScaleXByTime:
      this.LockYP[this.Proc]:=0
      this.LockYM[this.Proc]:=0
      if isobject(this.StampPos)
        StampLine:=this.StampPos.W/2
      else
        StampLine:=0
      this.Val_UnderGraph_Drawed[this.Proc]:=false
      if !this.ScaleXByTime
      {
        Old_CoordY:=ZeroPos
        Old_CoordX:=this.GPosW+10
        GPoints:=[[Old_CoordX,Old_CoordY]]
        if !this.GHide[this.Proc]
        loop,% this.GPosW
        {
          iLast:=a_index=this.GPosW
          i:=round(ArrSize-(a_index/Period+1))-this.X_Offset
          if (i<1 or i>ArrSize) and !iLast
            continue
          if iLast
          {
            if (i-1>0)
              i--
            else
              i:=Oldi
          }
          Aindex++
          if (Aindex=1 and i+1<=ArrSize)
          {
            if !this.TimeStampExist
              Value:=this.pData[i]
            else
              Value:=this.pData[i,1]
            tmp1:=Value?Value:0
            Value:=Value!=""?Value:"Null"
            if (tmp1!="")
            {
              hi_lim:=tmp1>hi_lim ? tmp1 : hi_lim
              lo_lim:=tmp1<lo_lim ? tmp1 : lo_lim
            }
            CoordY:=ZeroPos-tmp1*Pixel
            if (CoordY<-1)
              CoordY:=0
            else if (CoordY>this.GPosH+1)
              CoordY:=this.GPosH
            GPoints.Push([this.GPosW,CoordY])
          }
          if !this.TimeStampExist
            Value:=this.pData[i]
          else
            Value:=this.pData[i,1]
          tmp1:=Value?Value:0
          Value:=Value!=""?Value:"Null"
          if (tmp1!="")
          {
            hi_lim:=tmp1>hi_lim ? tmp1 : hi_lim
            lo_lim:=tmp1<lo_lim ? tmp1 : lo_lim
          }
          CoordX:=this.GPosW-a_index
          CoordY:=ZeroPos-tmp1*Pixel
          SkipLine:=false
          if (CoordY<-1)
          {
            CoordY:=0
            SkipLine:=true
            this.LockYP[this.Proc]++
          }
          else if (CoordY>this.GPosH+1)
          {
            CoordY:=this.GPosH
            SkipLine:=true
            this.LockYM[this.Proc]++
          }
          NewStamp:=false
          NewXMarker:=false
          if (Oldi!=i)
          {
            ; линия графика
            if !this.Smooth[this.Proc]
            {
              GPoints.Push([Old_CoordX,CoordY])
              Old_CoordY:=CoordY
            }
            GPoints.Push([CoordX,CoordY])
            ; Отрисовка подробностей при малом увеличении
            if (Oldi-i>1)
            {
              max:=Graph.min
              min:=Graph.max
              loop,% Oldi-i+1
              {
                j:=i+a_index-1
                if (j<1 or j>ArrSize)
                  continue
                if !this.TimeStampExist
                  tmp1:=this.pData[j]
                else
                  tmp1:=this.pData[j,1]
                min:=min<tmp1?min:tmp1
                max:=max>tmp1?max:tmp1
                if (tmp1!="")
                {
                  hi_lim:=tmp1>hi_lim ? tmp1 : hi_lim
                  lo_lim:=tmp1<lo_lim ? tmp1 : lo_lim
                }
              }
              min:=ZeroPos-min*Pixel
              max:=ZeroPos-max*Pixel
              if (min<0)
                min:=1
              if (min>this.GPosH)
                min:=this.GPosH
              if (max<0)
                max:=0
              if (max>this.GPosH)
                max:=this.GPosH-1
              GPoints.Push([CoordX,min])
              GPoints.Push([CoordX,max])
              GPoints.Push([CoordX,CoordY])
            }
            ; Дорисовать точки при большом увеличении
            if (Old_CoordX-CoordX>3)
              this.DrawEllipse(this.Pen[this.Proc],CoordX-1,CoordY-1,2,2,this.LineW[this.Proc])

            ; текст значения под курсором
            if (!this.Val_UnderGraph_Drawed[this.Proc] and MouseIn)
            if (mX>=CoordX and mX<=CoordX+20)
            if (mY>CoordY and mY<CoordY+20)
            {
              this.Val_UnderGraph_Drawed[this.Proc]:=true
              this.UnderGX[this.Proc]:=CoordX
              this.UnderGY[this.Proc]:=CoordY
              this.UnderGV[this.Proc]:=Value
            }
            Old_CoordX:=CoordX
            Old_CoordY:=CoordY
            Oldi:=i
            NewStamp:=true
            if (this.Sel=this.Proc)
              NewXMarker:=true
          }
          ; линия и текст временой шкалы
          if (this.Sel=this.Proc)
          {
            if Period>=1
              StampLine++
            else
              StampLine+=1
            if !isobject(this.StampPos)
              tmp1:=0
            else
              tmp1:=this.StampPos.W+2
            if (NewStamp and StampLine>tmp1) or (!Stamp and a_index=this.GPosW)
            {
              StampLine:=0
              Stamp:=true
              this.DrawLine(this.GrayPen2,CoordX,0,CoordX,this.GPosH)
              if !this.TimeStampExist
              {
                FormatTime,tmp10,% this.StampT[this.Proc,i,1],HH:mm:ss
                tmp10.="`n" this.StampT[this.Proc,i,2] "ms"
              }
              else
              {
                FormatTime,tmp10,% this.pData[i,2],dd.MM.yyyy'`n'HH:mm:ss
                if (TimeStampMillis and this.pData[i,3]!="")
                  tmp10.="." this.pData[i,3]
              }
              StampPos:=this.DrawString(tmp10,CoordX-this.StampPos.W/2,this.GPosH,,,,this.Font_Colour,this.GrayPen2)
              if !GetSizeOnce
              {
                GetSizeOnce:=true
                this.StampPos:=StampPos
                this.StampOffset:=this.StampPos.H
              }
              if (prevStampPos.w)
              {
                if (this.StampPos.X+this.StampPos.w>prevStampPos.X)
                  this.StampsNum--
                if (this.StampPos.X+this.StampPos.w*2+5<prevStampPos.X)
                  this.StampsNum++
                if this.StampsNum<2
                  this.StampsNum:=2
              }
              prevStampPos:=this.StampPos
            }
            ; маркеры
            tmp1:=this.GPosW-a_index
            loop,2
            {
              if (NewXMarker and !XMarker%a_index% and tmp1<this.XMarker[a_index])
              {
                XMarker%a_index%:=true
                XMarker%a_index%i:=i
                XMarker%a_index%Coord:=tmp1
              }
            }
            NewXMarker:=false
          }
        }
        ; рисовать линию графика
        if !this.GHide[this.Proc]
          this.DrawLines(this.Pen[this.Proc],GPoints,this.LineW[this.Proc])
        ; блокировать перемещение по Y
        this.LockYP[this.Proc]:=(this.LockYP[this.Proc]>=Aindex-3)?1:0
        this.LockYM[this.Proc]:=(this.LockYM[this.Proc]>=Aindex-3)?1:0
      }

      ScaleXByTime:
      if this.ScaleXByTime
      {
        Strt:=Graph.TimeSubMs([A_Now,A_MSec],this.XTOffset)
        if (this.Pause and (!this.SaveStrt[1] or this.OffsetSetting or this.ShiftStrt))
        {
          this.SaveStrt:=Strt
          this.ShiftStrt:=false
        }
        else if (!this.Pause and this.SaveStrt[1])
          this.SaveStrt:=""
        if this.Pause
          Strt:=this.SaveStrt
        Endt:=Graph.TimeSubMs(Strt,this.ZoomT)
        ; линия и текст временой шкалы
        if (this.Sel=this.Proc)
        {
          loop,% this.GPosW
          {
            CoordX:=this.GPosW-(a_index-1)
            StampLine++
            if !isobject(this.StampPos)
              tmp1:=0
            else
              tmp1:=this.StampPos.W+2
            if (StampLine>tmp1) or (!Stamp and a_index=this.GPosW)
            {
              Stamp:=true
              StampLine:=0
              this.DrawLine(this.GrayPen2,CoordX,0,CoordX,this.GPosH)
              tmp2:=(this.ZoomT/this.GPosW)*(a_index-1)
              tmp1:=Graph.TimeSubMs(Strt,tmp2)
              FormatTime,tmp10,% tmp1[1],dd.MM.yyyy'`n'HH:mm:ss
              tmp10.="." tmp1[2]
              StampPos:=this.DrawString(tmp10,CoordX-this.StampPos.W/2,this.GPosH,,,,this.Font_Colour,this.GrayPen2)
              if !GetSizeOnce
              {
                GetSizeOnce:=true
                this.StampPos:=StampPos
                this.StampOffset:=this.StampPos.H
              }
              if (prevStampPos.w)
              {
                if (this.StampPos.X+this.StampPos.w>prevStampPos.X)
                  this.StampsNum--
                if (this.StampPos.X+this.StampPos.w*2+5<prevStampPos.X)
                  this.StampsNum++
                if this.StampsNum<2
                  this.StampsNum:=2
              }
              prevStampPos:=this.StampPos
            }
          }
        }
        ; найти первую точку
        if !this.GHide[this.Proc]
        loop,% ArrSize
        {
          i:=ArrSize-(a_index-1)-this.SearchSkip[this.Proc]
          if (i<1)
          {
            iStart:=1
            break
          }
          if !this.TimeStampExist
          {
            iTime:=this.StampT[this.Proc,i,1]
            iTimeMs:=this.StampT[this.Proc,i,2]
          }
          else
          {
            iTime:=this.pData[i,2]
            if TimeStampMillis
              iTimeMs:=this.pData[i,3]
            else
            {
              if !Same
              {
                iTimeMs:=0
                loop,1000
                {
                  if (iTime=this.pData[i-a_index,2])
                    Same++
                  else
                  {
                    SameT:=1000/(Same+1)
                    break
                  }
                }
              }
              if (Same>0)
              {
                iTimeMs:=round(SameT*Same)
                Same--
              }
            }
          }
          if (iTime>Strt[1] or (TimeStampMillis and iTime=Strt[1] and iTimeMs>=Strt[2]))
            continue
          else
          {
            iStart:=i=ArrSize?i:i+1
            break
          }
        }
        Old_CoordY:=ZeroPos
        Old_CoordX:=this.GPosW+10
        GPoints:=[[Old_CoordX,Old_CoordY]]
        SearchSkip:=this.SearchSkip[this.Proc]?this.SearchSkip[this.Proc]:0
        Same:=0
        Aindex:=0
        iLast:=false
        if !this.GHide[this.Proc]
        loop,% iStart
        {
          i:=iStart-(a_index-1)
          if !this.TimeStampExist
          {
            iTime:=this.StampT[this.Proc,i,1]
            iTimeMs:=this.StampT[this.Proc,i,2]
          }
          else
          {
            iTime:=this.pData[i,2]
            if TimeStampMillis
              iTimeMs:=this.pData[i,3]
            else
            {
              if !Same
              {
                iTimeMs:=0
                loop,1000
                {
                  tmp1:=this.pData[i-a_index,2]
                  if (iTime=tmp1)
                    Same++
                  else
                  {
                    SameT:=1000/(Same+1)
                    break
                  }
                }
              }
              if (Same>0)
              {
                iTimeMs:=round(SameT*Same)
                Same--
              }
            }
          }
          if (iTime<Endt[1])
            iLast:=true
          mms:=Strt[2]-iTimeMs
          if (mms<0)
          {
            mms+=1000
            iTime+=1,Seconds
          }
          ttt:=Strt[1]
          ttt-=iTime,Seconds
          CoordX:=this.GPosW-round(PerioT*(ttt*1000+mms))
          Aindex++
          if (Aindex=1 and !this.SearchStop[this.Proc])
          {
            tmp1:=ArrSize-i
            if (SearchSkip<tmp1)
              SearchSkip:=tmp1
          }
          if (CoordX!=Old_CoordX or iLast)
          {
            if !this.TimeStampExist
              Value:=this.pData[i]
            else
              Value:=this.pData[i,1]
            tmp1:=Value?Value:0
            if (Value!="" and Aindex)
            {
              hi_lim:=Value>hi_lim ? Value : hi_lim
              lo_lim:=Value<lo_lim ? Value : lo_lim
            }
            Value:=Value!=""?Value:"Null"
            CoordY:=ZeroPos-tmp1*Pixel
            SkipLine:=false
            if (CoordY<-1)
            {
              CoordY:=0
              SkipLine:=true
              this.LockYP[this.Proc]++
            }
            else if (CoordY>this.GPosH+1)
            {
              CoordY:=this.GPosH
              SkipLine:=true
              this.LockYM[this.Proc]++
            }
            ; линия графика
            if !this.Smooth[this.Proc]
            {
              GPoints.Push([Old_CoordX,CoordY])
              Old_CoordY:=CoordY
            }
            GPoints.Push([CoordX,CoordY])
            ; Отрисовка подробностей при малом увеличении
            if (Oldi-i>1)
            {
              max:=Graph.min
              min:=Graph.max
              loop,% Oldi-i
              {
                j:=i+a_index-1
                if (j<1 or j>ArrSize)
                  continue
                if !this.TimeStampExist
                  tmp1:=this.pData[j]
                else
                  tmp1:=this.pData[j,1]
                min:=min<tmp1?min:tmp1
                max:=max>tmp1?max:tmp1
                if (tmp1!="")
                {
                  hi_lim:=tmp1>hi_lim ? tmp1 : hi_lim
                  lo_lim:=tmp1<lo_lim ? tmp1 : lo_lim
                }
              }
              min:=ZeroPos-min*Pixel
              max:=ZeroPos-max*Pixel
              if (min<0)
                min:=1
              if (min>this.GPosH)
                min:=this.GPosH
              if (max<0)
                max:=0
              if (max>this.GPosH)
                max:=this.GPosH-1
              GPoints.Push([CoordX,min])
              GPoints.Push([CoordX,max])
              GPoints.Push([CoordX,CoordY])
            }
            ; Дорисовать точки при большом увеличении
            if (Old_CoordX-CoordX>3)
              this.DrawEllipse(this.Pen[this.Proc],CoordX-1,CoordY-1,2,2,this.LineW[this.Proc])

            ; текст значения под курсором
            if (!this.Val_UnderGraph_Drawed[this.Proc] and MouseIn)
            if (mX>=CoordX and mX<=CoordX+20)
            if (mY>CoordY and mY<CoordY+20)
            {
              this.Val_UnderGraph_Drawed[this.Proc]:=true
              this.UnderGX[this.Proc]:=CoordX
              this.UnderGY[this.Proc]:=CoordY
              this.UnderGV[this.Proc]:=Value
            }
            Old_CoordX:=CoordX
            Old_CoordY:=CoordY
            Oldi:=i
            if iLast
              break
            ; маркеры
            if (this.Sel=this.Proc)
            {
              loop,2
              {
                if (!XMarker%a_index% and CoordX<this.XMarker[a_index])
                {
                  XMarker%a_index%:=true
                  XMarker%a_index%i:=i
                  if !TimeStampMillis
                    MarkerTimeMs%a_index%:=format("{:03}",iTimeMs)
                  XMarker%a_index%Coord:=CoordX
                }
              }
            }
          }
        }
        ; рисовать линию графика
        if !this.GHide[this.Proc]
          this.DrawLines(this.Pen[this.Proc],GPoints,this.LineW[this.Proc])
        this.ZoomX:=Aindex
        this.SearchSkip[this.Proc]:=SearchSkip

        ; блокировать перемещение по Y
        this.LockYP[this.Proc]:=(this.LockYP[this.Proc]>=Aindex-3)?1:0
        this.LockYM[this.Proc]:=(this.LockYM[this.Proc]>=Aindex-3)?1:0
      }
      ; Автомасштаб
      if (this.AutoScale[this.Proc] and !this.GHide[this.Proc])
      {
        tmp1:=this.GPosH//2
        if (this.ZeroPosU>tmp1 and this.ZeroPosU<this.GPosH+1)
        {
          if (hi_lim>0)
          {
            tmp2:=this.GPosH-this.ZeroPosU
            this.YScale[this.Proc]:=abs(hi_lim)+tmp2/Pixel
          }
          else
            this.YScale[this.Proc]:=-lo_lim+this.ZeroPosU/Pixel
        }
        else if (this.ZeroPosU<=tmp1 and this.ZeroPosU>0)
        {
          if (lo_lim<0)
            this.YScale[this.Proc]:=-lo_lim+this.ZeroPosU/Pixel
          else
          {
            tmp2:=this.GPosH-this.ZeroPosU
            this.YScale[this.Proc]:=abs(hi_lim)+tmp2/Pixel
          }
        }
        if (this.YScale[this.Proc]=0)
          this.YScale[this.Proc]:=1
      }
      this.DrawLine(this.GrayPen2,0,this.GPosH,this.GPosW,this.GPosH)
      this.DrawLine(this.GrayPen2,0,this.GPosH+StampPos.H,this.GPosW,this.GPosH+StampPos.H)

      ; текст значения под курсором
      if this.Val_UnderGraph_Drawed[this.Proc]
      {
        tmpX:=this.UnderGX[this.Proc]+5<this.GPosW-this.ValTipPosW?this.UnderGX[this.Proc]+5:this.GPosW-this.ValTipPosW
        tmpY:=this.UnderGY[this.Proc]-this.Pos.H<0?0:(this.UnderGY[this.Proc]-this.Pos.H-5)
        this.DrawEllipse(0xffffffff,this.UnderGX[this.Proc]-3,this.UnderGY[this.Proc]-3,6,6,this.LineW[this.Proc])
        this.DrawEllipse(0xff000000,this.UnderGX[this.Proc]-2,this.UnderGY[this.Proc]-2,4,4,this.LineW[this.Proc])
        this.DrawEllipse(0xffffffff,this.UnderGX[this.Proc]-1,this.UnderGY[this.Proc]-1,2,2,this.LineW[this.Proc])
        tmpc:=Graph.AHSVToARGB(200,this.Hue[this.Proc],this.Hue[this.Proc]>255?0:100,this.Hue[this.Proc]>255?(this.Hue[this.Proc]>>8):255)
        this.ValTipPos:=this.DrawString(this.UnderGV[this.Proc],tmpX,tmpY,,,,this.Font_Colour,tmpc)
        this.ValTipPosW:=this.ValTipPos.W
      }
      if (this.Sel=this.Proc)
      {
        loop,2
        {
          if XMarker%a_index%Coord
          {
            if !this.TimeStampExist
            {
              MarkerTime%a_index%:=this.StampT[this.Proc,XMarker%a_index%i,1]
              FormatTime,tmp10,% MarkerTime%a_index%,HH:mm:ss
              MarkerTimeMs%a_index%:=this.StampT[this.Proc,XMarker%a_index%i,2]
              MarkerTimeFormated%a_index%:=tmp10 "." MarkerTimeMs%a_index%
              MarkerValue%a_index%:=this.pData[XMarker%a_index%i]
              MarkerText%a_index%.=tmp10 "." MarkerTimeMs%a_index% " " MarkerValue%a_index% ""
            }
            else
            {
              MarkerTime%a_index%:=this.pData[XMarker%a_index%i,2]
              FormatTime,tmp10,% MarkerTime%a_index%,dd.MM.yyyy HH:mm:ss
              if (TimeStampMillis and this.pData[XMarker%a_index%i,3]!="")
                MarkerTimeMs%a_index%:=this.pData[XMarker%a_index%i,3]
              tmp10.="." MarkerTimeMs%a_index%
              MarkerTimeFormated%a_index%:=tmp10
              MarkerValue%a_index%:=this.pData[XMarker%a_index%i,1]

              MarkerText%a_index%.=tmp10 " " this.pData[XMarker%a_index%i,1] ""
            }
          }
        }
      }
    } ; Конец цикла
    if (Graph.HotKeymC=this.hGPos)
    {
      Graph.WheelUp:=false
      Graph.WheelDown:=false
    }

; Отрисовать меню
    OnGraphMenu:
    MenuSPY:=StampPos.Y+StampPos.H
    SelPos:=[]
    tmpc:=Graph.AHSVToARGB(200,this.Hue[1],this.Hue[1]>255?0:100,this.Hue[1]>255?(this.Hue[1]>>8):255)
    SelPos[1]:=this.DrawString("1",0,MenuSPY,,,"Center vCenter",this.GHide[1]?tmpc:this.Font_Colour,tmpc)
    loop,% Ars-1
    {
      tmp1:=a_index+1
      tmpc:=Graph.AHSVToARGB(200,this.Hue[tmp1],this.Hue[tmp1]>255?0:100,this.Hue[tmp1]>255?(this.Hue[tmp1]>>8):255)
      SelPos[tmp1]:=this.DrawString(tmp1,SelPos[a_index].X+SelPos[a_index].W+5,MenuSPY,,,"Center vCenter",this.GHide[tmp1]?tmpc:this.Font_Colour,tmpc)
    }
    MenuSPY:=StampPos.Y+StampPos.H+SelPos[1].H
    if !this.ScaleXByTime
      this.ZoomPos:=this.DrawString("Zoom X = " this.ZoomX " точек",0,MenuSPY,,,"",this.Font_Colour,this.LightBlueBrush)
    else
    {
      tmp1:=Graph.MsToTime(this.ZoomT)
      tmp1[1]-=1000000
      FormatTime,tmp2,% tmp1[1],dd HH:mm:ss
      tmp2.="." tmp1[2]
      this.ZoomPos:=this.DrawString("Zoom X = " tmp2,0,MenuSPY,,,"",this.Font_Colour,this.LightBlueBrush)
    }
    this.SmoothPos:=this.DrawString("Сглаживание",this.ZoomPos.W+this.Pos.W,MenuSPY,,,"",this.Smooth[this.Sel]?this.Font_Colour:this.GrayPen,this.LightBlueBrush)
    this.LineWPos:=this.DrawString("Толщина " this.LineW[this.Sel],this.SmoothPos.X+this.SmoothPos.W+this.Pos.W,MenuSPY,,,"",this.Font_Colour,this.LightBlueBrush)
    this.FontSizePos:=this.DrawString("Шрифт " this.FontSize,this.LineWPos.X+this.LineWPos.W+this.Pos.W,MenuSPY,,,"",this.Font_Colour,this.LightBlueBrush)
    ; следующая строка
    this.AutoPos:=this.DrawString("Авто",0,this.ZoomPos.Y+this.ZoomPos.H,,,"",this.AutoScale[this.Sel]?this.Font_Colour:this.GrayPen,this.LightBlueBrush)
    this.ScalePos:=this.DrawString("Шкала " this.YScale[this.Sel],this.AutoPos.X+this.AutoPos.W,this.AutoPos.Y,,,"",this.Font_Colour,this.LightBlueBrush)
    ; Размер меню
    tmp1:=(this.AutoPos.H>this.ScalePos.H)?this.AutoPos.H:this.ScalePos.H
    this.MenuOffset:=this.ZoomPos.H+tmp1+SelPos[1].H

    ; хитбоксы
    loop,% Ars
    {
      SelHB%a_index%:=Graph.HitBox(mX,mY,SelPos[a_index])
      if (SelHB%a_index%)
      {
        SelHB:=true
        break
      }
    }
    LineWHB:=Graph.HitBox(mX,mY,this.LineWPos)
    FontSizeHB:=Graph.HitBox(mX,mY,this.FontSizePos)
    ZoomHB:=Graph.HitBox(mX,mY,this.ZoomPos)
    SmoothHB:=Graph.HitBox(mX,mY,this.SmoothPos)
    AutoHB:=Graph.HitBox(mX,mY,this.AutoPos)
    ScaleHB:=Graph.HitBox(mX,mY,this.ScalePos)
    HB:=AutoHB or ScaleHB or ZoomHB or SmoothHB or LineWHB or FontSizeHB or SelHB
    if (MouseIn and HB and !this.OffsetSetting and !this.Setting and A_Cursor="Arrow")
    {
      this.Setting:=true
      if AutoHB
      {
        TipText:="Автоматический масштаб`n`n Нажмите для включения/отключения"
        this.WhichSetting:=1
      }
      else if ScaleHB
      {
        TipText:="Масштаб шкалы`n`nЗажмите левую `nкн. мыши и потяните`n для изменения"
        this.WhichSetting:=2
      }
      else if ZoomHB
      {
        TipText:="Зажмите левую `nкн. мыши и потяните`n для изменения"
        this.WhichSetting:=3
      }
      else if LineWHB
      {
        TipText:="Толщина линии графика`n`nЗажмите левую `nкн. мыши и потяните`n для изменения"
        this.WhichSetting:=4
      }
      else if SelHB
      {
        TipText:="Нажмите левой кн. мыши чтобы`n выбрать график`n настройки которого`n будут изменяться`n`nПравой кн. мыши`n выключить график"
        this.WhichSetting:=5
      }
      else if FontSizeHB
      {
        TipText:="Размер шрифта`n`nЗажмите левую `nкн. мыши и потяните`n для изменения"
        this.WhichSetting:=6
      }
      else if SmoothHB
      {
        TipText:="Сглаживать ступеньки графика`n`n Нажмите для включения/отключения"
        this.WhichSetting:=7
      }
      this.TipPos:=this.DrawString(TipText,(this.GPosW-this.TipPos.W)//2,this.GPosH-this.TipPos.H,,,,this.Font_Colour,this.LightGreenBrush)
    }
    ; Изменение настроек
    if (getkeystate("LButton","P") and this.Setting)
    {
      if (this.WhichSetting=1)
      {
        this.AutoScale[this.Sel]:=!this.AutoScale[this.Sel]
        this.WhichSetting:=0
      }
      else if (this.WhichSetting=2)
      {
        this.YScale[this.Sel]+=(round(abs(this.YScale[this.Sel])/20)+1)*DeltaY
        this.YScale[this.Sel]:=round(this.YScale[this.Sel])
        this.AutoScale[this.Sel]:=false
      }
      else if (this.WhichSetting=3)
      {
        this.ZoomX+=(round(abs(this.ZoomX)/20)+1)*DeltaY
        this.ZoomX:=(this.ZoomX>100000)?100000:(this.ZoomX<10)?10:round(this.ZoomX)
        this.ZoomT+=(round(abs(this.ZoomT)/20)+1)*DeltaY
        this.ZoomT:=(this.ZoomT>Graph.MaxTime)?Graph.MaxTime:(this.ZoomT<1000)?1000:round(this.ZoomT)
      }
      else if (this.WhichSetting=4)
      {
        this.LineW[this.Sel]+=DeltaY/10
        if (this.LineW[this.Sel]<1)
          this.LineW[this.Sel]:=1
        if (this.LineW[this.Sel]>5)
          this.LineW[this.Sel]:=5
        this.LineW[this.Sel]:=round(this.LineW[this.Sel],1)
      }
      else if (this.WhichSetting=5)
      {
        loop,% Ars
        {
          if (SelHB%a_index%)
          {
            this.Sel:=a_index
            this.UpdateMenu()
            break
          }
        }
        this.WhichSetting:=0
      }
      else if (this.WhichSetting=6)
      {
        this.FontSize+=DeltaY
        if (this.FontSize<8)
          this.FontSize:=8
        if (this.FontSize>70)
          this.FontSize:=70
        if (this.FontSize!=this.prevSize)
          this.SetFont(,this.FontSize)
      }
      else if (this.WhichSetting=7)
      {
        this.Smooth[this.Sel]:=!this.Smooth[this.Sel]
        this.WhichSetting:=0
      }
    }
    if (getkeystate("RButton","P") and this.Setting)
    {
      if (this.WhichSetting=5)
      {
        loop,% Ars
        {
          if (SelHB%a_index%)
          {
            this.GHide[a_index]:=!this.GHide[a_index]
            break
          }
        }
        this.WhichSetting:=0
      }
    }
    if (!getkeystate("LButton","P") and !getkeystate("RButton","P"))
    {
      this.Setting:=false
      this.WhichSetting:=0
    }

; Информация от маркеров
    Markers:
    max:=min:="`n"
    if this.ShowMarkers
    {
      loop,2
      {
        if XMarker%a_index%Coord
          this.DrawLine(this.RedPen,XMarker%a_index%Coord,0,XMarker%a_index%Coord,this.GPosH)
      }
      if !XMarker1Coord
        MarkerText1:="Нажмите левой кн. мыши на график"
      if !XMarker2Coord
        MarkerText2:="Нажмите правой кн. мыши на график"
      if (XMarker1Coord and XMarker2Coord)
      {
        i:=1, j:=2
        if (XMarker1Coord<XMarker2Coord)
          i:=2, j:=1
        tmp1:=Graph.TimeToMs(MarkerTime%i%)+MarkerTimeMs%i%
        tmp2:=Graph.TimeToMs(MarkerTime%j%)+MarkerTimeMs%j%
        ;YYYYMMDDHH24MISS
        MarkerTime%i%-=MarkerTime%j%,Seconds
        MarkerDeltaT:=1601
        MarkerDeltaT+=MarkerTime%i%,Seconds
        FormatTime,Y,% MarkerDeltaT,yyyy
        FormatTime,M,% MarkerDeltaT,MM
        FormatTime,D,% MarkerDeltaT,dd
        Y:=format("{:04}",Y-1601)
        M:=format("{:02}",M-1)
        D:=format("{:02}",D-1)
        if this.TimeStampExist
          MarkerDText.=D "." M "." Y " "

        tmp3:=Graph.MsToTime(tmp1-tmp2)
        tmp3:=tmp3[1]
        FormatTime,tmp10,% tmp3,HH:mm:ss
        MarkerDText.=tmp10

        if (MarkerTimeMs%i%!="")
        {
          StringRight,tmp1,% (tmp1-tmp2),3
          MarkerDText.="." tmp1
        }

        max:=Graph.min
        min:=Graph.max
        ValNum:=XMarker%i%i-XMarker%j%i+1
        loop,% ValNum
        {
          if !this.TimeStampExist
            Val:=this.pData[XMarker%j%i+A_Index-1]
          else
            Val:=this.pData[XMarker%j%i+A_Index-1,1]
          Summ+=Val
          if (Val>max)
            max:=Val
          if (Val<min)
            min:=Val
        }
        Mean:=Summ/ValNum
        loop,% ValNum
        {
          if !this.TimeStampExist
            Val:=this.pData[XMarker%j%i+A_Index-1]
          else
            Val:=this.pData[XMarker%j%i+A_Index-1,1]
          Deviation+=(Val-Mean)**2
        }
        StDeviation:=sqrt((Deviation/ValNum))
        StDeviation:="Среднекв. отклонение = " StDeviation
        Mean:="Среднее = " Mean
        min:="Min = " min
        max:="Max = " max
        ValNum:="Точек = " ValNum
      }
      String:=MarkerText1 "`n" MarkerText2 "`n" MarkerDText "`n" StDeviation "`n" Mean "`n" max "`n" min "`n" ValNum
      Pos:=this.DrawString(String,0,this.AutoPos.Y+this.AutoPos.H,this.GPosW,,"",this.Font_Colour,this.LightGreenBrush)
    }

; Подсказка о текущем увеличении
    if ((!this.ScaleXByTime and this.OldZoomX!=this.ZoomX) or this.OldZoomT!=this.ZoomT)
    {
      this.ShowZoomTip:=1000
      this.OldZoomX:=this.ZoomX
      this.OldZoomT:=this.ZoomT
    }
    if (this.ShowZoomTip>0)
    {
      this.ShowZoomTip-=CycleTime
      if !this.ScaleXByTime
        this.iZoomPos:=this.DrawString("Zoom`n" this.ZoomX "`nточек",(this.GPosW-this.iZoomPos.W)//2,0,,,,this.Font_Colour,this.LightGreenBrush)
      else
      {
        tmp1:=Graph.MsToTime(this.ZoomT)
        tmp1[1]+=-1000000
        FormatTime,tmp2,% tmp1[1],dd HH:mm:ss
        tmp2.="." tmp1[2]
        this.iZoomPos:=this.DrawString("Zoom`n" tmp2,(this.GPosW-this.iZoomPos.W)//2,0,,,,this.Font_Colour,this.LightGreenBrush)
      }
    }
; Подсказка о времени отрисовки
    DllCall("QueryPerformanceCounter","Int64*",EndTime)
    ElapsedTime:=round((EndTime-StartTime)/frequency*1000,1)
    this.ETPos:=this.DrawString(ElapsedTime "ms",this.GPosW-this.ETPos.W,this.ZoomPos.Y,,,,this.Font_Colour,this.Font_Back)
    if (Graph.HitBox(mX,mY,this.ETPos) and MouseIn)
      this.TipPos:=this.DrawString("Время отрисовки кадра",(this.GPosW-this.TipPos.W)//2,this.GPosH-this.TipPos.H,,,,this.Font_Colour,this.LightGreenBrush)

    if (ElapsedTime>1000)
    {
      if !this.ScaleXByTime
        this.ZoomX-=round(abs(this.ZoomX)/5)
      else
        this.ZoomT-=round(abs(this.ZoomT)/5)
    }

; Обновить изображение
    if !this.GuiHiden
      this.Update()
    this.OldmX:=mX
    this.OldmY:=mY
    this.FloatFormatFix()
  }
;||||/|||||||/|||||||/|||||||/|||||||/|||||||/|||||||/|||||||/|||||||/|||||||/|||||||/|||||||/||||
;|||///|||||///|||||///|||||///|||||///|||||///|||||///|||||///|||||///|||||///|||||///|||||///|||
;||/////|||/////|||/////|||/////|||/////|||/////|||/////|||/////|||/////|||/////|||/////|||/////||
;|///////|///////|///////|///////|///////|///////|///////|///////|///////|///////|///////|///////|
;/////////////////////////////////////////////////////////////////////////////////////////////////

  ConstrainXOffset()
  {
    if !this.ScaleXByTime
    {
      tmp1:=this.ZoomX//2
;      if (this.X_Offset>this.ArrSize[this.Proc]-tmp1)
;        this.X_Offset:=this.ArrSize[this.Proc]-tmp1
      if (this.X_Offset<-tmp1)
        this.X_Offset:=-tmp1
    }
    else
    {
      tmp1:=this.ZoomT//2
      if this.TimeStampExist
        tmp2:=Graph.TimeSub([A_Now,A_MSec],[this.pData[1,2],this.pData[1,3]])
      else
        tmp2:=Graph.TimeSub([A_Now,A_MSec],[this.StampT[this.Proc,1,1],this.StampT[this.Proc,1,2]])
;      if (this.XTOffset>tmp2-tmp1)
;        this.XTOffset:=tmp2-tmp1
      if (this.XTOffset<-tmp1)
        this.XTOffset:=-tmp1
    }
  }

  TimeSub(Time1,Time2)
  {
    T1:=Time1[1]
    T2:=Time2[1]
    ms:=Time1[2]-Time2[2]
    if (ms<0)
    {
      ms+=1000
      T2+=1,Seconds
    }
    T1-=T2,Seconds
    return T1*1000+ms
  }
  TimeSubMs(Time,ValueMs)
  {
    if (ValueMs=0)
      return Time
    m:=0
    if (ValueMs>0)
    {
      ms:=Time[2]-mod(ValueMs,1000)
      if (ms<0)
      {
        ms+=1000
        m:=1
      }
      t:=Time[1]
      t+=-(Floor(ValueMs/1000)+m),Seconds
    }
    else
    {
      ms:=mod(-ValueMs,1000)+Time[2]
      if (ms>999)
      {
        ms-=1000
        m:=1
      }
      t:=Time[1]
      t+=(Floor(-ValueMs/1000)+m),Seconds
    }
    return [t,format("{:03}",round(ms))]
  }
  TimeAddMs(Time,ValueMs)
  {
    T:=Time[1]
    T+=ValueMs//1000,Seconds
    ms:=Time[2]+mod(ValueMs,1000)
    if (ms>999)
    {
      ms-=1000
      T+=1,Seconds
    }
    return [T,format("{:03}",round(ms))]
  }
  TimeToMs(Time)
  {
    FormatTime,HH,% Time,HH
    FormatTime,MM,% Time,mm
    FormatTime,SS,% Time,ss
    return HH*3600000+MM*60000+SS*1000
  }
  MsToTime(Ms)
  {
    T:=1601
    T+=Ms//1000,Seconds
    Ms:=format("{:03}",mod(Ms,1000))
    return [T,Ms]
  }

  TTOk()
  {
    Gui,% this.hGuiTT . ":submit"
    GuiControlGet,ToTime,,% this.hTT
    tmp1:=A_Now
    tmp1-=ToTime,Seconds
    this.XTOffset:=tmp1*1000-round((this.GPosW/2)/this.PerioT)
    this.ConstrainXOffset()
    this.Pause:=true
    this.ShiftStrt:=true
  }
  TTCancel()
  {
    Gui,% this.hGuiTT . ":hide"
  }
  TXOk()
  {
    Gui,% this.hGuiTX . ":submit"
    GuiControlGet,ToX,,% this.hTX
    this.X_Offset:=this.ArrSize[this.Sel]-ToX
    this.ConstrainXOffset()
    this.Pause:=true
  }
  TXCancel()
  {
    Gui,% this.hGuiTX . ":hide"
  }

  HelpClose()
  {
    Gui,% this.hGuiHelp . ":hide"
  }

  MenuGColor()
  {
    tmp1:=Graph.ChooseColor(this.Pen[this.Sel],this.hGuiB)
    if (tmp1!="")
    {
      tmp2:=Graph.RGBToHSV(tmp1)
      if ((tmp2>>8)&0xff=0)
      {
        tmp3:=(tmp2&0xff)
        if (tmp3<127)
          tmp3:=127
        this.Hue[this.Sel]:=tmp3<<8
      }
      else
        this.Hue[this.Sel]:=tmp2>>16
      this.Pen[this.Sel]:=0xff000000 | tmp1
    }
  }
  MenuHelp()
  {
    hGuiHelp:=this.hGuiHelp
    Gui,%hGuiHelp%:show,,Справка
  }
  MenuGoTo()
  {
    if this.ScaleXByTime
    {
      hGuiTT:=this.hGuiTT
      Gui,%hGuiTT%:show,,Перейти на время
    }
    else
    {
      hGuiTX:=this.hGuiTX
      Gui,%hGuiTX%:show,,Перейти к точке
    }
  }
  MenuClose()
  {
    this.Hide()
  }
  MenuPause()
  {
    this.Pause:=!this.Pause
  }
  MenuForward()
  {
    this.Pause:=false
    this.XTOffset:=0
    this.X_Offset:=0
    this.ShiftStrt:=true
  }
  MenuBackward()
  {
    this.Pause:=true
    this.X_Offset:=this.ArrSize[this.Sel]-this.ZoomX//2
    if this.ScaleXByTime
    {
      tmp1:=A_Now
      if this.TimeStampExist
        tmp1-=this.pData[1,2],Seconds
      else
        tmp1-=this.StampT[this.Sel,1,1],Seconds
      this.XTOffset:=tmp1*1000-this.ZoomT//2
    }
    this.ShiftStrt:=true
  }
  MenuMarkers()
  {
    Add:=this.Pos.H*8
    if this.ShowMarkers:=!this.ShowMarkers
    {
      Size:=100+Add
      Number:=this.Number
      Gui,Graph%Number%:+MinSize300x%Size%
      WinGetPos,,,,BPosH,% "ahk_id" this.hGuiB
      WinMove,% "ahk_id" this.hGuiB,,,,,BPosH+Add
      this.MarkerOffset:=Add
    }
    else
    {
      Number:=this.Number
      Gui,Graph%Number%:+MinSize300x100
      WinGetPos,,,,BPosH,% "ahk_id" this.hGuiB
      WinMove,% "ahk_id" this.hGuiB,,,,,BPosH-Add
      this.MarkerOffset:=0
    }
  }
  MenuAutoScale()
  {
    if (this.Lock_hi_lim[this.Sel] or this.Lock_lo_lim[this.Sel])
      this.AutoScale[this.Sel]:=false
    Number:=this.Number
    if this.AutoScale[this.Sel]:=!this.AutoScale[this.Sel]
    {
      this.Lock_hi_lim[this.Sel]:=false
      this.Lock_lo_lim[this.Sel]:=false
      menu,GraphMenu%Number%settings,check,Автомасштаб
    }
    else
      menu,GraphMenu%Number%settings,uncheck,Автомасштаб
  }
  MenuAlwaysOnTop()
  {
    Number:=this.Number
    if this.AlwaysOnTop:=!this.AlwaysOnTop
    {
      Gui,Graph%Number%:+alwaysontop
      menu,GraphMenu%Number%settings,check,Всегда поверх окон
    }
    else
    {
      Gui,Graph%Number%:-alwaysontop
      menu,GraphMenu%Number%settings,uncheck,Всегда поверх окон
    }
  }
  MenuSmooth()
  {
    Number:=this.Number
    if this.Smooth[this.Sel]:=!this.Smooth[this.Sel]
      menu,GraphMenu%Number%settings,check,Сглаживать ступеньки
    else
      menu,GraphMenu%Number%settings,uncheck,Сглаживать ступеньки
  }
  MenuScaleXByTime()
  {
    Number:=this.Number
    this.ScaleXByTime:=true
    menu,GraphMenu%Number%settings,check,Масштабировать X по времени
    menu,GraphMenu%Number%settings,uncheck,Масштабировать X по точкам
  }
  MenuScaleXByDots()
  {
    Number:=this.Number
    this.ScaleXByTime:=false
    menu,GraphMenu%Number%settings,uncheck,Масштабировать X по времени
    menu,GraphMenu%Number%settings,check,Масштабировать X по точкам
  }
  MenuResetFont()
  {
    this.FontSize:=12
    this.SetFont(,this.FontSize)
  }
  UpdateMenu()
  {
    Number:=this.Number
    if this.AutoScale[this.Sel]
      menu,GraphMenu%Number%settings,check,Автомасштаб
    else
      menu,GraphMenu%Number%settings,uncheck,Автомасштаб
    if this.Smooth[this.Sel]
      menu,GraphMenu%Number%settings,check,Сглаживать ступеньки
    else
      menu,GraphMenu%Number%settings,uncheck,Сглаживать ступеньки
  }

  AHSVToARGB(a=255,h=0,s=0,v=0)
  {
    H:=h/255
    S:=s/255
    V:=v/255
    i:=Floor(H*6)
    f:=H*6-i
    p:=V*(1-S)
    q:=V*(1-f*S)
    t:=V*(1-(1-f)*S)
    sw:=mod(i,6)
    if (sw=0)
      r:=V, g:=t, b:=p
    if (sw=1)
      r:=q, g:=V, b:=p
    if (sw=2)
      r:=p, g:=V, b:=t
    if (sw=3)
      r:=p, g:=q, b:=V
    if (sw=4)
      r:=t, g:=p, b:=V
    if (sw=5)
      r:=V, g:=p, b:=q
    r:=(r*255)&0xff
    g:=(g*255)&0xff
    b:=(b*255)&0xff
    return (a<<24 | r<<16 | g<<8 | b)
  }
  RGBToHSV(RGB)
  {
    r:=(RGB>>16 & 0xff)/255
    g:=(RGB>>8 & 0xff)/255
    b:=(RGB & 0xff)/255
    min:=(r<g)?((r<b)?r:b):((g<b)?g:b)
    val:=(r>g)?((r>b)?r:b):((g>b)?g:b)
    delta:=val-min
    if (delta=0) ;pure blackness
      return (RGB & 0xff)
    if (r=val) ;between yellow and magenta
      hue:=(g-b)/delta
    else if (g=val) ;between cyan and yellow
      hue:=2+(b-r)/delta
    else ;between magenta and cyan
      hue:=4+(r-g)/delta
    if (hue<=0)
      hue+=6
    hue:=round(hue/6*255)
    sat:=round((Delta/val)*255)
    val:=round(val*255)
    return (hue<<16 | sat<<8 | val)
  }
  Show(x="",y="")
  {
    this.GuiHiden:=false
    hGuiB:=this.hGuiB
    if (x="")
      x:=a_screenwidth//2-400
    if (y="")
      y:=a_screenheight//2-200
    Gui,%hGuiB%:show,% "x" x " y" y,% this.Name
    obm:=this.UpdateTimer
    settimer,% obm,% this.UpdatePeriod
  }

  Hide()
  {
    this.GuiHiden:=true
    obm:=this.UpdateTimer
    settimer,% obm,off
    this.Update(0)
    Gui,% this.hGuiB . ":hide"
  }

  Create()
  {
    this.hDC:=DllCall("CreateCompatibleDC","UPtr",0)
    VarSetCapacity(bi,40,0)
    NumPut(40,bi,0,"uint")
    NumPut(A_ScreenWidth,bi,4,"uint")
    NumPut(A_ScreenHeight,bi,8,"uint")
    NumPut(1,bi,12,"ushort")
    NumPut(32,bi,14,"ushort")
    NumPut(0,bi,16,"uInt")
    this.hBitmap:=DllCall("CreateDIBSection"
                     ,"Ptr",this.hDC
                     ,"Ptr",&bi
                     ,"uint",0
                     ,"UPtr*",0
                     ,"Ptr",0
                     ,"uint",0,"Ptr")
    this.obm:=DllCall("SelectObject","Ptr",this.hDC,"Ptr",this.hBitmap)
    DllCall(Graph.hGdipCreateFromHDC,"Ptr",this.hDC,"UPtr*",pGraphics)
    this.pGraphics:=pGraphics
    DllCall(Graph.hGdipSetSmoothingMode,"UPtr",this.pGraphics,"Int",4)
  }

  Update(Alpha=255)
  {
    wingetpos,,,BPosW,BPosH,% "ahk_id" this.hGuiB
    if (this.PrevW!=BPosW or this.PrevH!=BPosH)
    {
      Pos:=Graph.GetClientSize(this.hGuiB)
      WinMove,% "ahk_id" this.hGPos,,0,0,Pos.W-1,Pos.H-1
      this.PrevW:=BPosW
      this.PrevH:=BPosH
    }
    wingetpos,GPosX,GPosY,GPosW,GPosH,% "ahk_id" this.hGPos
    this.GPosW:=GPosW
    this.GPosH:=GPosH-this.StampOffset-this.MarkerOffset-this.MenuOffset
    this.GPosH_:=GPosH
    this.ZeroPosU:=this.GPosH-this.ZeroPos
    VarSetCapacity(pt,8)
    NumPut(GPosX,pt,0,"UInt")
    NumPut(GPosY,pt,4,"UInt")
    DllCall("UpdateLayeredWindow"
            ,"Ptr",this.hGuiG
            ,"Ptr",0
            ,"Ptr",&pt
            ,"int64*",GPosW|GPosH<<32
            ,"Ptr",this.hDC
            ,"int64*",0
            ,"uint",0
            ,"UInt*",Alpha<<16|1<<24
            ,"uint",2)
  }

  GetClientSize(hwnd)
  {
    VarSetCapacity(rc,16)
    DllCall("GetClientRect","uint",hwnd,"uint",&rc)
    return {"X":NumGet(rc,0,"int"),"Y":NumGet(rc,4,"int"),"W":NumGet(rc,8,"int"),"H":NumGet(rc,12,"int")}
  }

  CreateSolidBrush(ARGB=0xff000000)
  {
    DllCall(Graph.hGdipCreateSolidFill,"UInt",ARGB,"UPtr*",pBrush)
    return pBrush
  }
  DeleteBrush(byref pBrush)
  {
    DllCall(Graph.hGdipDeleteBrush,"UPtr",pBrush)
    pBrush:=""
  }
  CreatePen(ARGB=0xff000000,w=1)
  {
    DllCall(Graph.hGdipCreatePen1,"UInt",ARGB,"float",w,"int",2,"UPtr*",pPen)
    return pPen
  }
  DeletePen(byref pPen)
  {
    DllCall(Graph.hGdipDeletePen,"UPtr",pPen)
    pPen:=""
  }

  FillRectangle(ARGB,x,y,w,h)
  {
    if (!this.pBrush or this.prevBrushColor!=ARGB)
    {
      if this.pBrush
        Graph.DeleteBrush(this.pBrush)
      this.pBrush:=Graph.CreateSolidBrush(ARGB)
    }
    this.prevBrushColor:=ARGB
    DllCall(Graph.hGdipFillRectangle
            ,"Ptr",this.pGraphics
            ,"Ptr",this.pBrush
            ,"float",x
            ,"float",y
            ,"float",w
            ,"float",h)
    return {"X":x,"Y":y,"W":w,"H":h}
  }
  DrawLine(ARGB,x1,y1,x2,y2,LineWidth=1)
  {
    if (!this.pPen or this.prevPenColor!=ARGB or this.OldLineWidth!=LineWidth)
    {
      if this.pPen
        Graph.DeletePen(this.pPen)
      this.pPen:=Graph.CreatePen(ARGB,LineWidth)
    }
    this.OldLineWidth:=LineWidth
    this.prevPenColor:=ARGB
    DllCall(Graph.hGdipDrawLine
            ,Ptr,this.pGraphics
            ,Ptr,this.pPen
            ,"float",x1
            ,"float",y1
            ,"float",x2
            ,"float",y2)
    return {"X1":x1,"Y1":y1,"X2":x2,"Y2":y2}
  }
  DrawLines(ARGB,Points,LineWidth=1)
  {
    tmp1:=Points.MaxIndex()
    if !tmp1
      return -1
    VarSetCapacity(PointF,8*tmp1)
    Loop,% tmp1
    {
      NumPut(Points[a_index,1],PointF,8*(A_Index-1),"float")
      NumPut(Points[a_index,2],PointF,(8*(A_Index-1))+4,"float")
    }

    if (!this.pPen or this.prevPenColor!=ARGB or this.OldLineWidth!=LineWidth)
    {
      if this.pPen
        Graph.DeletePen(this.pPen)
      this.pPen:=Graph.CreatePen(ARGB,LineWidth)
    }
    this.OldLineWidth:=LineWidth
    this.prevPenColor:=ARGB
    return DllCall(Graph.hGdipDrawLines
                   ,"Ptr",this.pGraphics
                   ,"Ptr",this.pPen
                   ,"Ptr",&PointF
                   ,"int",tmp1)
  }
  DrawEllipse(ARGB,x,y,w,h,LineWidth=1)
  {
    if (!this.pPen or this.prevPenColor!=ARGB or this.OldLineWidth!=LineWidth)
    {
      if this.pPen
        Graph.DeletePen(this.pPen)
      this.pPen:=Graph.CreatePen(ARGB,LineWidth)
    }
    this.OldLineWidth:=LineWidth
    this.prevPenColor:=ARGB
    DllCall(Graph.hGdipDrawEllipse
              ,"Ptr",this.pGraphics
              ,"Ptr",this.pPen
              ,"float",x
              ,"float",y
              ,"float",w
              ,"float",h)
    return {"X":x,"Y":y,"W":w,"H":h}
  }
  DrawRectangle(ARGB,x,y,w,h,LineWidth=1)
  {
    if (!this.pPen or this.prevPenColor!=ARGB or this.OldLineWidth!=LineWidth)
    {
      if this.pPen
        Graph.DeletePen(this.pPen)
      this.pPen:=Graph.CreatePen(ARGB,LineWidth)
    }
    this.OldLineWidth:=LineWidth
    this.prevPenColor:=ARGB
    DllCall(Graph.hGdipDrawRectangle
                ,"Ptr",this.pGraphics
                , "Ptr",this.pPen
                , "float",x
                , "float",y
                , "float",w
                , "float",h)
    return {"X":x,"Y":y,"W":w,"H":h}
  }

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

    if (!this.hFormat or (this.prevNoWrap!=NoWrap and NoWrap!=""))
    {
      if this.hFormat
      {
        DllCall(Graph.hGdipDeleteStringFormat,"UPtr",this.hFormat)
        this.hFormat:=""
      }
      DllCall(Graph.hGdipCreateStringFormat,"int",NoWrap ? 0x4000 | 0x1000 : 0x4000,"int",0,"UPtr*",hFormat)
      this.hFormat:=hFormat
      this.prevNoWrap:=NoWrap
    }

    if (!this.hFamily or (this.prevFont!=Font and Font!=""))
    {
      if this.hFamily
      {
        if this.hFont
        {
          DllCall(Graph.hGdipDeleteFont,"UPtr",this.hFont)
          this.hFont:=""
        }
        DllCall(Graph.hGdipDeleteFontFamily,"UPtr",this.hFamily)
        this.hFamily:=""
      }
      Font:=Font="" ? "Arial" : Font
      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(Graph.hGdipCreateFontFamilyFromName
              ,"Ptr",A_IsUnicode ? &Font : &wFont
              ,"uint",0
              ,"UPtr*",hFamily)
      this.hFamily:=hFamily
      this.prevFont:=Font
    }

    if (!this.hFont or (this.prevSize!=Size and Size!="") or (this.prevfStyle!=fStyle and fStyle!=""))
    {
      if this.hFont
      {
        DllCall(Graph.hGdipDeleteFont,"UPtr",this.hFont)
        this.hFont:=""
      }
      DllCall(Graph.hGdipCreateFont,"UPtr",this.hFamily,"float",(Size ? Size : 12),"int",fStyle="" ? 0 : Style,"int",0,"UPtr*",hFont)
      this.hFont:=hFont
      this.prevSize:=Size
      this.prevfStyle:=fStyle
    }

    RenderingHint:=(RenderingHint="") ? ((this.prevRenderingHint="") ? 0 : this.prevRenderingHint) : RenderingHint
    this.prevRenderingHint:=RenderingHint
    ; SystemDefault = 0
    ; SingleBitPerPixelGridFit = 1
    ; SingleBitPerPixel = 2
    ; AntiAliasGridFit = 3
    ; AntiAlias = 4
    DllCall(Graph.hGdipSetTextRenderingHint,"UPtr",this.pGraphics,"int",RenderingHint)
  }

  DrawString(Text,xpos=0,ypos=0,Width=0,Height=0,Options="Center",Colour=0xff000000,BackgroundColour=0)
  {
    RegExMatch(Options,"i)Top|Up|Bottom|Down|vCentre|vCenter",vPos)

    if !(this.hFamily and this.hFont and this.hFormat)
      this.SetFont()

    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
    }
    DllCall(Graph.hGdipSetStringFormatAlign,"UPtr",this.hFormat,"int",Align)

    if (!this.FontpBrush or Colour!=this.prevColour)
    {
      if this.FontpBrush
        Graph.DeleteBrush(this.FontpBrush)
      this.FontpBrush:=Graph.CreateSolidBrush(Colour)
      this.prevColour:=Colour
    }

    Graph.CreateRectF(RC,xpos,ypos,Width,Height)
    ReturnRC:=this.MeasureString(Text,RC)
    if (!Width or !Height)
    {
      Width:=Width ? Width : ReturnRC.W
      Height:=Height ? Height : ReturnRC.H
      Graph.CreateRectF(RC,xpos,ypos,Width,Height)
      ReturnRC:=this.MeasureString(Text,RC)
    }
    if BackgroundColour
      this.FillRectangle(BackgroundColour,xpos,ypos,Width,Height)
    if vPos
    {
      if (vPos="vCentre" or vPos="vCenter")
        ypos+=(Height-ReturnRC.H)//2
      else if (vPos="Top" or vPos="Up")
        ypos:=ReturnRC.Y
      else if (vPos="Bottom" or vPos="Down")
        ypos+=Height-ReturnRC.H

      Graph.CreateRectF(RC,xpos,ypos,Width,ReturnRC.H)
      ReturnRC:=this.MeasureString(Text,RC)
    }

    sString:=Text
    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)
    }
    DllCall(Graph.hGdipDrawString
            ,"Ptr",this.pGraphics
            ,"Ptr",A_IsUnicode ? &sString : &wString
            ,"int",-1
            ,"Ptr",this.hFont
            ,"Ptr",&RC
            ,"Ptr",this.hFormat
            ,"Ptr",this.FontpBrush)

    return ReturnRC
  }
  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")
  }

  MeasureString(sString,ByRef RectF)
  {
    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)
    }

    if !DllCall(Graph.hGdipMeasureString
            ,"Ptr",this.pGraphics
            ,"Ptr",A_IsUnicode ? &sString : &wString
            ,"int",-1
            ,"Ptr",this.hFont
            ,"Ptr",&RectF
            ,"Ptr",this.hFormat
            ,"Ptr",&RC
            ,"uint*",Chars
            ,"uint*",Lines)
    return {"X":NumGet(RC, 0, "float"),"Y":NumGet(RC, 4, "float"),"W":NumGet(RC, 8, "float"),"H":NumGet(RC, 12, "float"),"Chars":Chars,"Lines":Lines}
  }
}

#if WinActive("ahk_class AutoHotkeyGUI",Graph.WinText)
WheelUp::
MouseGetPos,,,,mC,2
Graph.WheelUp:=true
Graph.HotKeymC:=mC
return
WheelDown::
MouseGetPos,,,,mC,2
Graph.WheelDown:=true
Graph.HotKeymC:=mC
return
#if




/*  Windows Color Picker Plus (by rbrtryn)
    https-//autohotkey.com/board/topic/91229-windows-color-picker-plus/
    Edited by me lemasato-
        BGR2RGB()-
        Use Format() to convert the value to hex instead of SetFormat

    Function- ChooseColor([pRGB, hOwner, DlgX, DlgY, Palette])
        Displays a standard Windows dialog for choosing colors.
    Parameters-
        pRGB - The initial color to display in the dialog in RGB format.
               The default setting is Black.
        hOwner - The Window ID of the dialog's owner, if it has one. Defaults to
                0, i.e. no owner. If specified DlgX and DlgY are ignored.
        DlgX, DlgY - The X and Y coordinates of the upper left corner of the
                     dialog. Both default to 0.
        Palette - An array of up to 16 RGB color values. These become the
                  initial custom colors in the dialog.
    Remarks-
        The custom colors in the dialog are remembered between calls.

        If the user selects OK, the Palette array (if it exists) will be loaded
        with the custom colors from the dialog.
    Returns-
        If the user selects OK, the selected color is returned in RGB format
        and ErrorLevel is set to 0. Otherwise, the original pRGB value is
        returned and ErrorLevel is set to 1.
*/
ChooseColor(pRGB := 0, hOwner := 0, DlgX := 0, DlgY := 0, Palette*)
{
    static CustColors    ; Custom colors are remembered between calls
    static SizeOfCustColors := VarSetCapacity(CustColors, 64, 0)
    static StructSize := VarSetCapacity(ChooseColor, 9 * A_PtrSize, 0)

    CustData := (DlgX << 16) | DlgY    ; Store X in high word, Y in the low word

;___Load user's custom colors
    for Index, Value in Palette
        NumPut(BGR2RGB(Value), CustColors, (Index - 1) * 4, "UInt")

;___Set up a ChooseColor structure as described in the MSDN
    NumPut(StructSize, ChooseColor, 0, "UInt")
    NumPut(hOwner, ChooseColor, A_PtrSize, "UPtr")
    NumPut(BGR2RGB(pRGB), ChooseColor, 3 * A_PtrSize, "UInt")
    NumPut(&CustColors, ChooseColor, 4 * A_PtrSize, "UPtr")
    NumPut(0x113, ChooseColor, 5 * A_PtrSize, "UInt")
    NumPut(CustData, ChooseColor, 6 * A_PtrSize, "UInt")
    NumPut(RegisterCallback("ColorWindowProc"), ChooseColor, 7 * A_PtrSize, "UPtr")

;___Call the function
    ErrorLevel := ! DllCall("comdlg32\ChooseColor", "UPtr", &ChooseColor, "UInt")

;___Save the changes made to the custom colors
    if not ErrorLevel
        Loop 16
            Palette[A_Index] := BGR2RGB(NumGet(CustColors, (A_Index - 1) * 4, "UInt"))
    if !ErrorLevel ; modified by Alectric
      return BGR2RGB(NumGet(ChooseColor, 3 * A_PtrSize, "UINT"))
}

/*!
    Function- ColorWindowProc(hwnd, msg, wParam, lParam)
        Callback function used to modify the Color dialog before it is displayed
    Parameters-
        hwnd - Handle to the Color dialog window.
        msg - The message sent to the window.
        wParam - The handle to the control that has the keyboard focus.
        lParam - A pointer to the ChooseColor structure associated with the
                 Color dialog.
    Remarks-
        This is intended to be a private function, called only by ChooseColor.
        In response to a WM_INITDIALOG message, this function can be used to
        modify the Color dialog before it is displayed. Currently it just moves
        the window to a new X, Y location.
    Returns-
        If the hook procedure returns zero, the default dialog box procedure
        also processes the message. Otherwise, the default dialog box procedure
        ignores the message.
*/
ColorWindowProc(hwnd, msg, wParam, lParam)
{
    static WM_INITDIALOG := 0x0110

    if (msg <> WM_INITDIALOG)
        return 0

    hOwner := NumGet(lParam+0, A_PtrSize, "UPtr")
    if (hOwner)
        return 0

    DetectSetting := A_DetectHiddenWindows
    DetectHiddenWindows On
    CustData := NumGet(lParam+0, 6 * A_PtrSize, "UInt")
    DlgX := CustData >> 16, DlgY := CustData & 0xFFFF
    WinMove ahk_id %hwnd%, , %DlgX%, %DlgY%

    DetectHiddenWindows %DetectSetting%
    return 0
}

/*!
    Function- BGR2RGB(Color)
        Converts a BGR color value to a RGB one or vice versa.
    Parameters-
        Color - The BGR or RGB value to convert
    Returns-
        The converted value.
*/
BGR2RGB(Color)
{
    ret :=  (Color & 0xFF000000)
         | ((Color & 0xFF0000) >> 16)
         |  (Color & 0x00FF00)
         | ((Color & 0x0000FF) << 16)
    return ret
}

username := "username"
email := "email@gmail.com"
password := "password"
authorization := "Bearer AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA"   ; twitter always uses exactly this one
auth_token = 0a0205c12365f6355613b6f2d486d474b6   ; if wrong, will be generated by script
csrf_token = b8caffd5c8d32770003427c21416baa0daff78c   ; if wrong, will be generated by script
WinHTTP := ComObjCreate("WinHTTP.WinHttpRequest.5.1")

getTweets:
url := "https://twitter.com/i/api/2/search/adaptive.json?include_profile_interstitial_type=1&include_blocking=1&include_blocked_by=1&include_followed_by=1&include_want_retweets=1&include_mute_edge=1&include_can_dm=1&include_can_media_tag=1&include_ext_has_nft_avatar=1&include_ext_is_blue_verified=1&include_ext_verified_type=1&include_ext_profile_image_shape=1&skip_status=1&cards_platform=Web-12&include_cards=1&include_ext_alt_text=true&include_ext_limited_action_results=false&include_quote_count=true&include_reply_count=1&tweet_mode=extended&include_ext_views=true&include_entities=true&include_user_entities=true&include_ext_media_color=true&include_ext_media_availability=true&include_ext_sensitive_media_warning=true&include_ext_trusted_friends_metadata=true&send_error_codes=true&simple_quoted_tweet=true&q=from%3AhtGOIW%20since%3A2009-11-01%20until%3A2011-01-01&tweet_search_mode=live&query_source=typed_query&count=20&requestContext=launch&pc=1&spelling_corrections=1&include_ext_edit_control=true&ext=mediaStats%2ChighlightedLabel%2ChasNftAvatar%2CvoiceInfo%2CbirdwatchPivot%2Cenrichments%2CsuperFollowMetadata%2CunmentionInfo%2CeditControl%2Cvibe"
WinHTTP.Open("GET", url, true)
WinHTTP.SetRequestHeader("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36")
WinHTTP.SetRequestHeader("Pragma", "no-cache")
WinHTTP.SetRequestHeader("Cache-Control", "no-cache, no-store")
WinHTTP.SetRequestHeader("If-Modified-Since", "Sat, 1 Jan 2000 00:00:00 GMT")
WinHTTP.SetRequestHeader("authorization", authorization)
WinHTTP.SetRequestHeader("x-csrf-token", csrf_token)
WinHTTP.SetRequestHeader("cookie", "auth_token=" auth_token "; ct0=" csrf_token)
WinHTTP.Send()
WinHTTP.WaitForResponse()
if RegexMatch(WinHTTP.ResponseText, "^\{""errors""")
{
   GoSub login
   GoTo getTweets
}
msgbox % WinHTTP.ResponseText
return

login:
WinHTTP.Open("GET", "https://twitter.com/i/flow/login", true)
WinHTTP.SetRequestHeader("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36")
WinHTTP.SetRequestHeader("Pragma", "no-cache")
WinHTTP.SetRequestHeader("Cache-Control", "no-cache, no-store")
WinHTTP.SetRequestHeader("If-Modified-Since", "Sat, 1 Jan 2000 00:00:00 GMT")
WinHTTP.Send()
WinHTTP.WaitForResponse()
RegexMatch(WinHTTP.ResponseText, "s)document\.cookie=""gt=(.+?);", match)
guest_token := match1

body = {"input_flow_data":{"flow_context":{"debug_overrides":{},"start_location":{"location":"manual_link"}}},"subtask_versions":{"action_list":2,"alert_dialog":1,"app_download_cta":1,"check_logged_in_account":1,"choice_selection":3,"contacts_live_sync_permission_prompt":0,"cta":7,"email_verification":2,"end_flow":1,"enter_date":1,"enter_email":2,"enter_password":5,"enter_phone":2,"enter_recaptcha":1,"enter_text":5,"enter_username":2,"generic_urt":3,"in_app_notification":1,"interest_picker":3,"js_instrumentation":1,"menu_dialog":1,"notifications_permission_prompt":2,"open_account":2,"open_home_timeline":1,"open_link":1,"phone_verification":4,"privacy_options":1,"security_key":3,"select_avatar":4,"select_banner":2,"settings_list":7,"show_code":1,"sign_up":2,"sign_up_review":4,"tweet_selection_urt":1,"update_users":1,"upload_media":1,"user_recommendations_list":4,"user_recommendations_urt":1,"wait_spinner":3,"web_modal":1}}
WinHTTP.Open("POST", "https://api.twitter.com/1.1/onboarding/task.json?flow_name=login", true)
WinHTTP.SetRequestHeader("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36")
WinHTTP.SetRequestHeader("Pragma", "no-cache")
WinHTTP.SetRequestHeader("Cache-Control", "no-cache, no-store")
WinHTTP.SetRequestHeader("If-Modified-Since", "Sat, 1 Jan 2000 00:00:00 GMT")
WinHTTP.SetRequestHeader("content-type", "application/json")
WinHTTP.SetRequestHeader("authorization", authorization)
WinHTTP.SetRequestHeader("x-guest-token", guest_token)
WinHTTP.Send(body)
WinHTTP.WaitForResponse()
RegexMatch(WinHTTP.ResponseText, "s)""flow_token"":""(.+?)""", match)
flow_token := match1

body = {"flow_token":"%flow_token%","subtask_inputs":[]}
WinHTTP.Open("POST", "https://api.twitter.com/1.1/onboarding/task.json", true)
WinHTTP.SetRequestHeader("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36")
WinHTTP.SetRequestHeader("Pragma", "no-cache")
WinHTTP.SetRequestHeader("Cache-Control", "no-cache, no-store")
WinHTTP.SetRequestHeader("If-Modified-Since", "Sat, 1 Jan 2000 00:00:00 GMT")
WinHTTP.SetRequestHeader("content-type", "application/json")
WinHTTP.SetRequestHeader("authorization", authorization)
WinHTTP.SetRequestHeader("x-guest-token", guest_token)
WinHTTP.Send(body)
WinHTTP.WaitForResponse()
RegexMatch(WinHTTP.ResponseText, "s)""flow_token"":""(.+?)""", match)
flow_token := match1

body = {"flow_token":"%flow_token%","subtask_inputs":[{"subtask_id":"LoginEnterUserIdentifierSSO","settings_list":{"setting_responses":[{"key":"user_identifier","response_data":{"text_data":{"result":"%username%"}}}],"link":"next_link"}}]}
WinHTTP.Open("POST", "https://api.twitter.com/1.1/onboarding/task.json", true)
WinHTTP.SetRequestHeader("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36")
WinHTTP.SetRequestHeader("Pragma", "no-cache")
WinHTTP.SetRequestHeader("Cache-Control", "no-cache, no-store")
WinHTTP.SetRequestHeader("If-Modified-Since", "Sat, 1 Jan 2000 00:00:00 GMT")
WinHTTP.SetRequestHeader("content-type", "application/json")
WinHTTP.SetRequestHeader("authorization", authorization)
WinHTTP.SetRequestHeader("x-guest-token", guest_token)
WinHTTP.Send(body)
WinHTTP.WaitForResponse()
RegexMatch(WinHTTP.ResponseText, "s)""flow_token"":""(.+?)""", match)
flow_token := match1

if InStr(WinHTTP.ResponseText, "LoginEnterAlternateIdentifierSubtask")
{
   body = {"flow_token":"%flow_token%","subtask_inputs":[{"subtask_id":"LoginEnterAlternateIdentifierSubtask","enter_text":{"text":"%email%","link":"next_link"}}]}
   WinHTTP.Open("POST", "https://api.twitter.com/1.1/onboarding/task.json", true)
   WinHTTP.SetRequestHeader("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36")
   WinHTTP.SetRequestHeader("Pragma", "no-cache")
   WinHTTP.SetRequestHeader("Cache-Control", "no-cache, no-store")
   WinHTTP.SetRequestHeader("If-Modified-Since", "Sat, 1 Jan 2000 00:00:00 GMT")
   WinHTTP.SetRequestHeader("content-type", "application/json")
   WinHTTP.SetRequestHeader("authorization", authorization)
   WinHTTP.SetRequestHeader("x-guest-token", guest_token)
   WinHTTP.Send(body)
   WinHTTP.WaitForResponse()
   RegexMatch(WinHTTP.ResponseText, "s)""flow_token"":""(.+?)""", match)
   flow_token := match1
}

body = {"flow_token":"%flow_token%","subtask_inputs":[{"subtask_id":"LoginEnterPassword","enter_password":{"password":"%password%","link":"next_link"}}]}
WinHTTP.Open("POST", "https://api.twitter.com/1.1/onboarding/task.json", true)
WinHTTP.SetRequestHeader("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36")
WinHTTP.SetRequestHeader("Pragma", "no-cache")
WinHTTP.SetRequestHeader("Cache-Control", "no-cache, no-store")
WinHTTP.SetRequestHeader("If-Modified-Since", "Sat, 1 Jan 2000 00:00:00 GMT")
WinHTTP.SetRequestHeader("content-type", "application/json")
WinHTTP.SetRequestHeader("authorization", authorization)
WinHTTP.SetRequestHeader("x-guest-token", guest_token)
WinHTTP.Send(body)
WinHTTP.WaitForResponse()
RegexMatch(WinHTTP.ResponseText, "s)""flow_token"":""(.+?)""", match)
flow_token := match1

body = {"flow_token":"%flow_token%","subtask_inputs":[{"subtask_id":"AccountDuplicationCheck","check_logged_in_account":{"link":"AccountDuplicationCheck_false"}}]}
WinHTTP.Open("POST", "https://api.twitter.com/1.1/onboarding/task.json", true)
WinHTTP.SetRequestHeader("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36")
WinHTTP.SetRequestHeader("Pragma", "no-cache")
WinHTTP.SetRequestHeader("Cache-Control", "no-cache, no-store")
WinHTTP.SetRequestHeader("If-Modified-Since", "Sat, 1 Jan 2000 00:00:00 GMT")
WinHTTP.SetRequestHeader("content-type", "application/json")
WinHTTP.SetRequestHeader("authorization", authorization)
WinHTTP.SetRequestHeader("x-guest-token", guest_token)
WinHTTP.Send(body)
WinHTTP.WaitForResponse()
RegexMatch(WinHTTP.getallresponseheaders, "s)Set-Cookie: ct0=(.+?);.+?Set-Cookie: auth_token=(.+?);", match)
csrf_token := match1, auth_token := match2

WinHTTP.Open("GET", "https://twitter.com/i/api/graphql/XeaGEEWXp54Km4mVNvcMmg/Viewer?variables=%7B%22withCommunitiesMemberships%22%3Atrue%2C%22withSubscribedTab%22%3Atrue%2C%22withCommunitiesCreation%22%3Atrue%7D&features=%7B%22blue_business_profile_image_shape_enabled%22%3Atrue%2C%22responsive_web_graphql_exclude_directive_enabled%22%3Atrue%2C%22verified_phone_label_enabled%22%3Afalse%2C%22responsive_web_graphql_skip_user_profile_image_extensions_enabled%22%3Afalse%2C%22responsive_web_graphql_timeline_navigation_enabled%22%3Atrue%7D", true)
WinHTTP.SetRequestHeader("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36")
WinHTTP.SetRequestHeader("Pragma", "no-cache")
WinHTTP.SetRequestHeader("Cache-Control", "no-cache, no-store")
WinHTTP.SetRequestHeader("If-Modified-Since", "Sat, 1 Jan 2000 00:00:00 GMT")
WinHTTP.SetRequestHeader("authorization", authorization)
WinHTTP.SetRequestHeader("x-csrf-token", csrf_token)
WinHTTP.Send()
WinHTTP.WaitForResponse()
RegexMatch(WinHTTP.getallresponseheaders, "s)Set-Cookie: ct0=(.+?);", match)
csrf_token := match1
msgbox % "auth_token = " auth_token "`ncsrf_token = " csrf_token
return

#Requires AutoHotkey v2.0.2 ; and OS >= Windows 10

if !ClipboardHistory.HistoryEnabled {
    if MsgBox('Clipboard history disabled, want to enable?', 'Clipboard History', 'YN') = 'No'
        ExitApp
    ClipboardHistory.HistoryEnabled := true
}
MsgBox 'Clipboard history enabled'
MsgBox ClipboardHistory.GetHistoryItemText(1), 'First item text'
MsgBox ClipboardHistory.DeleteHistoryItem(1), 'Boolean success status'   ; deletes the first history item and returns boolean success status
MsgBox ClipboardHistory.GetHistoryItemText(1), 'First item text'
MsgBox ClipboardHistory.PutHistoryItemIntoClipboard(2), 'Success status' ; puts the second history item into Clipboard and returns succsess status
MsgBox A_Clipboard, 'Clipboard content'

formats := ''
for fmt in ClipboardHistory.GetAvailableFormats(2) { ; available formats of the second history item
    formats .= fmt . '`n'
}
MsgBox formats, 'Available Formats'

historyItemCount := ClipboardHistory.Count
Loop historyItemCount {
    MsgBox ClipboardHistory.GetHistoryItemText(A_Index), 'Item ' . A_Index . ' of ' . historyItemCount, 'T.7'
}

class ClipboardHistory
{
; properties
    static HistoryEnabled {
        get => CBH_API.HistoryEnabled
        set => CBH_API.HistoryEnabled := value ; boolean
    }
    static Count => CBH_API.GetClipboardHistoryItems()

; methods
    static ClearHistory()                     => CBH_API.ClearHistory()
    static DeleteHistoryItem(index)           => CBH_API.DeleteHistoryItem(index) ; 1 based index
    static GetHistoryItemText(index)          => CBH_API.GetHistoryItemText(index)
    static PutHistoryItemIntoClipboard(index) => CBH_API.PutHistoryItemIntoClipboard(index)
    static GetAvailableFormats(index)         => CBH_API.GetAvailableFormats(index)
}

class CBH_API
{
    /*
        https://is.gd/bYyogJ     Clipboard Class (MSDN)
        https://is.gd/2z2Y9G     Windows.ApplicationModel.DataTransfer.0.h (GitHub)
        https://is.gd/T4Lb7b     asyncinfo.h (GitHub)
    */
    static HistoryEnabled {
        get => IClipboardStatics2.IsHistoryEnabled
        set => RegWrite(!!value, 'REG_DWORD', 'HKCU\SOFTWARE\Microsoft\Clipboard', 'EnableClipboardHistory')
    }

    static ClearHistory() => IClipboardStatics2.ClearHistory()

    static DeleteHistoryItem(index) { ; 1 based
        if !pIClipboardHistoryItem := this.GetClipboardHistoryItemByIndex(index)
            return false
        bool := IClipboardStatics2.DeleteItemFromHistory(pIClipboardHistoryItem)
        ObjRelease(pIClipboardHistoryItem)
        return bool
    }

    static GetHistoryItemText(index) {
        if !DataPackageView := this.GetDataPackageView(index)
            return
        ReadOnlyList := IReadOnlyList(DataPackageView.AvailableFormats)
        textFound := false
        Loop ReadOnlyList.Count
            HSTRING := ReadOnlyList.Item[A_Index - 1]
        until WrtString(HSTRING).GetText() = 'Text' && textFound := true
        if !textFound
            return
        HSTRING := this.Await(DataPackageView.GetTextAsync())
        return WrtString(HSTRING).GetText()
    }

    static GetAvailableFormats(index) {
        if !DataPackageView := this.GetDataPackageView(index)
            return
        ReadOnlyList := IReadOnlyList(DataPackageView.AvailableFormats)
        AvailableFormats := []
        Loop ReadOnlyList.Count {
            HSTRING := ReadOnlyList.Item[A_Index - 1]
            AvailableFormats.Push(WrtString(HSTRING).GetText())
        }
        return AvailableFormats
    }

    static GetDataPackageView(index) {
        if !pIClipboardHistoryItem := this.GetClipboardHistoryItemByIndex(index)
            return
        pIDataPackageView := IClipboardHistoryItem(pIClipboardHistoryItem).Content
        return IDataPackageView(pIDataPackageView)
    }

    static PutHistoryItemIntoClipboard(index) {
        static SetHistoryItemAsContentStatus := ['Success', 'AccessDenied', 'ItemDeleted']
        if !pIClipboardHistoryItem := this.GetClipboardHistoryItemByIndex(index)
            return
        status := IClipboardStatics2.SetHistoryItemAsContent(pIClipboardHistoryItem)
        ObjRelease(pIClipboardHistoryItem)
        return SetHistoryItemAsContentStatus[status + 1]
    }

    static GetClipboardHistoryItemByIndex(index) { ; 1 based
        count := this.GetClipboardHistoryItems(&ReadOnlyList)
        if (count < index) {
            MsgBox 'Index "' . index . '" exceeds items count!'
            return
        }
        return pIClipboardHistoryItem := ReadOnlyList.Item[index - 1]
    }

    static GetClipboardHistoryItems(&ReadOnlyList := '') {
        pIClipboardHistoryItemsResult := this.Await(IClipboardStatics2.GetHistoryItemsAsync())
        ClipboardHistoryItemsResult := IClipboardHistoryItemsResult(pIClipboardHistoryItemsResult)
        pIReadOnlyList := ClipboardHistoryItemsResult.Items
        ReadOnlyList := IReadOnlyList(pIReadOnlyList)
        return ReadOnlyList.Count
    }

    static Await(pIAsyncOperation) {
        static AsyncStatus := ['Started', 'Completed', 'Canceled', 'Error']
        AsyncOperation := IAsyncOperation(pIAsyncOperation)
        pIAsyncInfo := AsyncOperation.QueryIAsyncInfo()
        AsyncInfo := IAsyncInfo(pIAsyncInfo)
        Loop {
            Sleep 10
            status := AsyncStatus[AsyncInfo.Status + 1]
        } until status != 'Started'
        if (status != 'Completed')
            throw OSError('AsyncInfo error, status: "' . status . '"', A_ThisFunc)
        return AsyncOperation.GetResults()
    }
}

class IClipboardStatics2
{
    static __New() {
        static IID_IClipboardStatics2 := '{D2AC1B6A-D29F-554B-B303-F0452345FE02}', VT_UNKNOWN := 0xD
        if !(A_OSVersion ~= '^10\.')
            throw OSError('This class requires Windows 10 or later!', A_ThisFunc)
        
        WrtStr := WrtString('Windows.ApplicationModel.DataTransfer.Clipboard')
        DllCall('Ole32\CLSIDFromString', 'Str', IID_IClipboardStatics2, 'Ptr', CLSID := Buffer(16))
        this.comObj := ComValue(VT_UNKNOWN, WrtStr.GetFactory(CLSID))
        this.ptr := this.comObj.ptr
    }
    static GetHistoryItemsAsync() => (ComCall(6, this, 'UIntP', &pIAsyncOperation := 0), pIAsyncOperation)

    static ClearHistory() => (ComCall(7, this, 'UIntP', &res := 0), res)

    static DeleteItemFromHistory(pIClipboardHistoryItem) => (ComCall(8, this, 'Ptr', pIClipboardHistoryItem, 'UIntP', &res := 0), res)

    static SetHistoryItemAsContent(pIClipboardHistoryItem) => (ComCall(9, this, 'Ptr', pIClipboardHistoryItem, 'UIntP', &res := 0), res)

    static IsHistoryEnabled => (ComCall(10, this, 'UIntP', &res := 0), res)
}

class IClipboardHistoryItemsResult extends _InterfaceBase
{
    Items => (ComCall(7, this, 'PtrP', &pIReadOnlyList := 0), pIReadOnlyList)
}

class IClipboardHistoryItem extends _InterfaceBase
{
    Content => (ComCall(8, this, 'PtrP', &pIDataPackageView := 0), pIDataPackageView)
}

class IDataPackageView extends _InterfaceBase
{
    AvailableFormats => (ComCall(9, this, 'PtrP', &pIReadOnlyList := 0), pIReadOnlyList)

    GetTextAsync() => (ComCall(12, this, 'UIntP', &pIAsyncOperation := 0), pIAsyncOperation)
}

class IReadOnlyList extends _InterfaceBase
{
    Item[index] => (ComCall(6, this, 'Int', index, 'PtrP', &pItem := 0), pItem)

    Count => (ComCall(7, this, 'UIntP', &count := 0), count)
}

class IAsyncOperation extends _InterfaceBase
{
    QueryIAsyncInfo() => ComObjQuery(this, IID_IAsyncInfo := '{00000036-0000-0000-C000-000000000046}')

    GetResults() => (ComCall(8, this, 'PtrP', &pResult := 0), pResult)
}

class IAsyncInfo extends _InterfaceBase
{
    Status => (ComCall(7, this, 'PtrP', &status := 0), status)
}

class _InterfaceBase
{
    __New(ptr) {
        this.comObj := ComValue(VT_UNKNOWN := 0xD, ptr)
        this.ptr := this.comObj.ptr
    }
}

class WrtString
{
    __New(stringOrHandle) {
        if Type(stringOrHandle) = 'Integer'
            this.ptr := stringOrHandle
        else {
            DllCall('Combase\WindowsCreateString', 'WStr', stringOrHandle, 'UInt', StrLen(stringOrHandle), 'PtrP', &HSTRING := 0)
            this.ptr := HSTRING
        }
    }
    __Delete() {
        DllCall('Combase\WindowsDeleteString', 'Ptr', this)
    }
    GetText() {
        buf := DllCall('Combase\WindowsGetStringRawBuffer', 'Ptr', this, 'UIntP', &len := 0, 'Ptr')
        return StrGet(buf, len, 'UTF-16')
    }
    GetFactory(riid) {
        hr := DllCall('Combase\RoGetActivationFactory', 'Ptr', this, 'Ptr', riid, 'PtrP', &pInterface := 0)
        if (hr != 0)
            throw OSError(WrtString.SysError(hr), A_ThisFunc)
        return pInterface
    }
    static SysError(nError := '') {
        static flags := (FORMAT_MESSAGE_ALLOCATE_BUFFER := 0x100) | (FORMAT_MESSAGE_FROM_SYSTEM := 0x1000)
        (nError = '' && nError := A_LastError)
        DllCall('FormatMessage', 'UInt', flags, 'UInt', 0, 'UInt', nError, 'UInt', 0, 'PtrP', &pBuf := 0, 'UInt', 128)
        err := (str := StrGet(pBuf)) = '' ? nError : str
        DllCall('LocalFree', 'Ptr', pBuf)
        return err
    }
}

; global captureCursor := true   ; раскомментировать если нужен захват курсора.
; global hwndExclude := [0x1111, 0x2222]   ; массив hwnd окон, исключенных из захвата
OnExit, Uninitialize
setbatchlines -1
return

f11::
savedesktop("temp")
return

savedesktop(name)
{
   static hChildMagnifier, RECT, this
   varsetcapacity(this, StrLen(name)+1, 0)
   StrPut(name, &this, "utf-8")
   if !hChildMagnifier
   {
      Gui, Magnifier: +HWNDhMagnifier +toolwindow -Caption +E0x00080000 +E0x20 ; WS_EX_LAYERED := E0x00080000 WS_EX_TRANSPARENT := E0x20
      DllCall("LoadLibrary", "str", "magnification.dll")
      DllCall("magnification.dll\MagInitialize")
      if (captureCursor = "")
         captureCursor := 0
      hChildMagnifier := DllCall("CreateWindowEx", "uint", 0, "str", "Magnifier", "str", "MagnifierWindow", "uint", (WS_CHILD := 0x40000000)|captureCursor, "int", 0, "int", 0, "int", A_ScreenWidth, "int", A_ScreenHeight, "uptr", hMagnifier, "uint", 0, "ptr", DllCall("GetWindowLong" (A_PtrSize=8 ? "Ptr" : ""), "uptr", hMagnifier, "int", GWL_HINSTANCE := -6 , "ptr"), "uint", 0, "ptr")
      if hwndExclude
      {
         VarSetCapacity(HWNDlist, hwndExclude.Count() * A_PtrSize, 0)
         loop % hwndExclude.Count()
            NumPut(hwndExclude[A_Index], HWNDlist, (A_Index - 1) * A_PtrSize, "ptr")
         DllCall("magnification.dll\MagSetWindowFilterList", "uptr", hChildMagnifier, "int", MW_FILTERMODE_EXCLUDE := 0, "int", hwndExclude.Count(), "ptr", &HWNDlist)
      }
      matrix := "1|0|0|0|1|0|0|0|1"  
      VarSetCapacity(MAGTRANSFORM, 36, 0)
      loop, parse, matrix, |
         NumPut(A_LoopField, MAGTRANSFORM, (A_Index-1)*4, "float")
      DllCall("magnification.dll\MagSetWindowTransform", "uptr", hChildMagnifier, "ptr", &MAGTRANSFORM)
      DllCall("magnification.dll\MagSetImageScalingCallback", "uptr", hChildMagnifier, "ptr", RegisterCallback("MagImageScalingCallback", "Fast",, &this))
      if (A_PtrSize = 8)
      {
         VarSetCapacity(RECT, 16, 0)
         NumPut(0, RECT, 0, "int")
         NumPut(0, RECT, 4, "int")
         NumPut(A_ScreenWidth, RECT, 8, "int")
         NumPut(A_ScreenHeight, RECT, 12, "int")
      }
   }
   if (A_PtrSize = 8)
      DllCall("magnification.dll\MagSetWindowSource", "uptr", hChildMagnifier, "ptr", &RECT)
   else
      DllCall("magnification.dll\MagSetWindowSource", "uptr", hChildMagnifier, "int", 0, "int", 0, "int", A_ScreenWidth, "int", A_ScreenHeight)
   return
}

MagImageScalingCallback(hwnd, srcdata, srcheader, destdata, destheader, unclipped, clipped, dirty)
{
   static hDC, BITMAPV5HEADER, BITMAPINFO, pCodec, extension := "jpg"
   if !hDC
   {  
      DllCall("LoadLibrary", "str", "gdiplus")
      VarSetCapacity(si, A_PtrSize = 8 ? 24 : 16, 0), si := Chr(1)
      DllCall("gdiplus\GdiplusStartup", "ptr*", pToken, "ptr", &si, "ptr", 0)
      DllCall("gdiplus\GdipGetImageEncodersSize", "uint*", count:=0, "uint*", size:=0)
      VarSetCapacity(ci, size)
      DllCall("gdiplus\GdipGetImageEncoders", "uint", count, "uint", size, "ptr", &ci)
      if !(count && size)
         throw Exception("Could not get a list of image codec encoders on this system.")
      Loop % count
         EncoderExtensions := StrGet(NumGet(ci, (idx:=(48+7*A_PtrSize)*(A_Index-1))+32+3*A_PtrSize, "uptr"), "UTF-16")
      until InStr(EncoderExtensions, "*." extension)
      if !(pCodec := &ci + idx)
         throw Exception("Could not find a matching encoder for the specified file format.")
      VarSetCapacity(BITMAPV5HEADER, 124, 0)
      NumPut(124, BITMAPV5HEADER, 0, "uint")   ; bV5Size
      NumPut(A_ScreenWidth, BITMAPV5HEADER, 4, "uint")   ; bV5Width
      NumPut(-A_ScreenHeight, BITMAPV5HEADER, 8, "uint")   ; bV5Height
      NumPut(1, BITMAPV5HEADER, 12, "short")   ; bV5Planes
      NumPut(32, BITMAPV5HEADER, 14, "short")   ; bV5BitCount
      VarSetCapacity(BITMAPINFO, 44, 0)
      NumPut(44, BITMAPINFO, 0, "uint")   ; biSize
      NumPut(A_ScreenWidth, BITMAPINFO, 4, "uint")   ; biWidth
      NumPut(-A_ScreenHeight, BITMAPINFO, 8, "UInt")   ; biHeight
      NumPut(1, BITMAPINFO, 12, "short")   ; biPlanes
      NumPut(32, BITMAPINFO, 14, "short")   ; biBitCount
      hDC := DllCall("GetDC", "uptr", hwnd)
   }
   hBitmap := DllCall("CreateDIBitmap", "ptr", hDC, "ptr", &BITMAPV5HEADER, "uint", CBM_INIT := 6, "ptr", srcdata, "ptr", &BITMAPINFO, "uint", DIB_RGB_COLORS := 0, "ptr")
   DllCall("gdiplus\GdipCreateBitmapFromHBITMAP", "ptr", hBitmap, "ptr", 0, "ptr*", pBitmap)
   DllCall("gdiplus\GdipSaveImageToFile", "ptr", pBitmap, "wstr", strget(A_EventInfo, "utf-8") "." extension, "ptr", pCodec, "uint", 0)
   DllCall("gdiplus\GdipDisposeImage", "ptr", pBitmap)
   DllCall("DeleteObject", "ptr", hBitmap)
   return
}

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