github.com/secoba/wails/v2@v2.6.4/internal/frontend/desktop/windows/winc/w32/kernel32.go (about) 1 //go:build windows 2 3 /* 4 * Copyright (C) 2019 Tad Vizbaras. All Rights Reserved. 5 * Copyright (C) 2010-2012 The W32 Authors. All Rights Reserved. 6 */ 7 package w32 8 9 import ( 10 "syscall" 11 "unsafe" 12 ) 13 14 var ( 15 modkernel32 = syscall.NewLazyDLL("kernel32.dll") 16 17 procGetModuleHandle = modkernel32.NewProc("GetModuleHandleW") 18 procMulDiv = modkernel32.NewProc("MulDiv") 19 procGetConsoleWindow = modkernel32.NewProc("GetConsoleWindow") 20 procGetCurrentThread = modkernel32.NewProc("GetCurrentThread") 21 procGetCurrentThreadId = modkernel32.NewProc("GetCurrentThreadId") 22 procGetLogicalDrives = modkernel32.NewProc("GetLogicalDrives") 23 procGetLogicalDriveStrings = modkernel32.NewProc("GetLogicalDriveStringsW") 24 procGetUserDefaultLCID = modkernel32.NewProc("GetUserDefaultLCID") 25 procLstrlen = modkernel32.NewProc("lstrlenW") 26 procLstrcpy = modkernel32.NewProc("lstrcpyW") 27 procGlobalAlloc = modkernel32.NewProc("GlobalAlloc") 28 procGlobalFree = modkernel32.NewProc("GlobalFree") 29 procGlobalLock = modkernel32.NewProc("GlobalLock") 30 procGlobalUnlock = modkernel32.NewProc("GlobalUnlock") 31 procMoveMemory = modkernel32.NewProc("RtlMoveMemory") 32 procFindResource = modkernel32.NewProc("FindResourceW") 33 procSizeofResource = modkernel32.NewProc("SizeofResource") 34 procLockResource = modkernel32.NewProc("LockResource") 35 procLoadResource = modkernel32.NewProc("LoadResource") 36 procGetLastError = modkernel32.NewProc("GetLastError") 37 procOpenProcess = modkernel32.NewProc("OpenProcess") 38 procTerminateProcess = modkernel32.NewProc("TerminateProcess") 39 procCloseHandle = modkernel32.NewProc("CloseHandle") 40 procCreateToolhelp32Snapshot = modkernel32.NewProc("CreateToolhelp32Snapshot") 41 procModule32First = modkernel32.NewProc("Module32FirstW") 42 procModule32Next = modkernel32.NewProc("Module32NextW") 43 procGetSystemTimes = modkernel32.NewProc("GetSystemTimes") 44 procGetConsoleScreenBufferInfo = modkernel32.NewProc("GetConsoleScreenBufferInfo") 45 procSetConsoleTextAttribute = modkernel32.NewProc("SetConsoleTextAttribute") 46 procGetDiskFreeSpaceEx = modkernel32.NewProc("GetDiskFreeSpaceExW") 47 procGetProcessTimes = modkernel32.NewProc("GetProcessTimes") 48 procSetSystemTime = modkernel32.NewProc("SetSystemTime") 49 procGetSystemTime = modkernel32.NewProc("GetSystemTime") 50 ) 51 52 func GetModuleHandle(modulename string) HINSTANCE { 53 var mn uintptr 54 if modulename == "" { 55 mn = 0 56 } else { 57 mn = uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(modulename))) 58 } 59 ret, _, _ := procGetModuleHandle.Call(mn) 60 return HINSTANCE(ret) 61 } 62 63 func MulDiv(number, numerator, denominator int) int { 64 ret, _, _ := procMulDiv.Call( 65 uintptr(number), 66 uintptr(numerator), 67 uintptr(denominator)) 68 69 return int(ret) 70 } 71 72 func GetConsoleWindow() HWND { 73 ret, _, _ := procGetConsoleWindow.Call() 74 75 return HWND(ret) 76 } 77 78 func GetCurrentThread() HANDLE { 79 ret, _, _ := procGetCurrentThread.Call() 80 81 return HANDLE(ret) 82 } 83 84 func GetCurrentThreadId() HANDLE { 85 ret, _, _ := procGetCurrentThreadId.Call() 86 87 return HANDLE(ret) 88 } 89 90 func GetLogicalDrives() uint32 { 91 ret, _, _ := procGetLogicalDrives.Call() 92 93 return uint32(ret) 94 } 95 96 func GetUserDefaultLCID() uint32 { 97 ret, _, _ := procGetUserDefaultLCID.Call() 98 99 return uint32(ret) 100 } 101 102 func Lstrlen(lpString *uint16) int { 103 ret, _, _ := procLstrlen.Call(uintptr(unsafe.Pointer(lpString))) 104 105 return int(ret) 106 } 107 108 func Lstrcpy(buf []uint16, lpString *uint16) { 109 procLstrcpy.Call( 110 uintptr(unsafe.Pointer(&buf[0])), 111 uintptr(unsafe.Pointer(lpString))) 112 } 113 114 func GlobalAlloc(uFlags uint, dwBytes uint32) HGLOBAL { 115 ret, _, _ := procGlobalAlloc.Call( 116 uintptr(uFlags), 117 uintptr(dwBytes)) 118 119 if ret == 0 { 120 panic("GlobalAlloc failed") 121 } 122 123 return HGLOBAL(ret) 124 } 125 126 func GlobalFree(hMem HGLOBAL) { 127 ret, _, _ := procGlobalFree.Call(uintptr(hMem)) 128 129 if ret != 0 { 130 panic("GlobalFree failed") 131 } 132 } 133 134 func GlobalLock(hMem HGLOBAL) unsafe.Pointer { 135 ret, _, _ := procGlobalLock.Call(uintptr(hMem)) 136 137 if ret == 0 { 138 panic("GlobalLock failed") 139 } 140 141 return unsafe.Pointer(ret) 142 } 143 144 func GlobalUnlock(hMem HGLOBAL) bool { 145 ret, _, _ := procGlobalUnlock.Call(uintptr(hMem)) 146 147 return ret != 0 148 } 149 150 func MoveMemory(destination, source unsafe.Pointer, length uint32) { 151 procMoveMemory.Call( 152 uintptr(unsafe.Pointer(destination)), 153 uintptr(source), 154 uintptr(length)) 155 } 156 157 func FindResource(hModule HMODULE, lpName, lpType *uint16) (HRSRC, error) { 158 ret, _, _ := procFindResource.Call( 159 uintptr(hModule), 160 uintptr(unsafe.Pointer(lpName)), 161 uintptr(unsafe.Pointer(lpType))) 162 163 if ret == 0 { 164 return 0, syscall.GetLastError() 165 } 166 167 return HRSRC(ret), nil 168 } 169 170 func SizeofResource(hModule HMODULE, hResInfo HRSRC) uint32 { 171 ret, _, _ := procSizeofResource.Call( 172 uintptr(hModule), 173 uintptr(hResInfo)) 174 175 if ret == 0 { 176 panic("SizeofResource failed") 177 } 178 179 return uint32(ret) 180 } 181 182 func LockResource(hResData HGLOBAL) unsafe.Pointer { 183 ret, _, _ := procLockResource.Call(uintptr(hResData)) 184 185 if ret == 0 { 186 panic("LockResource failed") 187 } 188 189 return unsafe.Pointer(ret) 190 } 191 192 func LoadResource(hModule HMODULE, hResInfo HRSRC) HGLOBAL { 193 ret, _, _ := procLoadResource.Call( 194 uintptr(hModule), 195 uintptr(hResInfo)) 196 197 if ret == 0 { 198 panic("LoadResource failed") 199 } 200 201 return HGLOBAL(ret) 202 } 203 204 func GetLastError() uint32 { 205 ret, _, _ := procGetLastError.Call() 206 return uint32(ret) 207 } 208 209 func OpenProcess(desiredAccess uint32, inheritHandle bool, processId uint32) HANDLE { 210 inherit := 0 211 if inheritHandle { 212 inherit = 1 213 } 214 215 ret, _, _ := procOpenProcess.Call( 216 uintptr(desiredAccess), 217 uintptr(inherit), 218 uintptr(processId)) 219 return HANDLE(ret) 220 } 221 222 func TerminateProcess(hProcess HANDLE, uExitCode uint) bool { 223 ret, _, _ := procTerminateProcess.Call( 224 uintptr(hProcess), 225 uintptr(uExitCode)) 226 return ret != 0 227 } 228 229 func CloseHandle(object HANDLE) bool { 230 ret, _, _ := procCloseHandle.Call( 231 uintptr(object)) 232 return ret != 0 233 } 234 235 func CreateToolhelp32Snapshot(flags, processId uint32) HANDLE { 236 ret, _, _ := procCreateToolhelp32Snapshot.Call( 237 uintptr(flags), 238 uintptr(processId)) 239 240 if ret <= 0 { 241 return HANDLE(0) 242 } 243 244 return HANDLE(ret) 245 } 246 247 func Module32First(snapshot HANDLE, me *MODULEENTRY32) bool { 248 ret, _, _ := procModule32First.Call( 249 uintptr(snapshot), 250 uintptr(unsafe.Pointer(me))) 251 252 return ret != 0 253 } 254 255 func Module32Next(snapshot HANDLE, me *MODULEENTRY32) bool { 256 ret, _, _ := procModule32Next.Call( 257 uintptr(snapshot), 258 uintptr(unsafe.Pointer(me))) 259 260 return ret != 0 261 } 262 263 func GetSystemTimes(lpIdleTime, lpKernelTime, lpUserTime *FILETIME) bool { 264 ret, _, _ := procGetSystemTimes.Call( 265 uintptr(unsafe.Pointer(lpIdleTime)), 266 uintptr(unsafe.Pointer(lpKernelTime)), 267 uintptr(unsafe.Pointer(lpUserTime))) 268 269 return ret != 0 270 } 271 272 func GetProcessTimes(hProcess HANDLE, lpCreationTime, lpExitTime, lpKernelTime, lpUserTime *FILETIME) bool { 273 ret, _, _ := procGetProcessTimes.Call( 274 uintptr(hProcess), 275 uintptr(unsafe.Pointer(lpCreationTime)), 276 uintptr(unsafe.Pointer(lpExitTime)), 277 uintptr(unsafe.Pointer(lpKernelTime)), 278 uintptr(unsafe.Pointer(lpUserTime))) 279 280 return ret != 0 281 } 282 283 func GetConsoleScreenBufferInfo(hConsoleOutput HANDLE) *CONSOLE_SCREEN_BUFFER_INFO { 284 var csbi CONSOLE_SCREEN_BUFFER_INFO 285 ret, _, _ := procGetConsoleScreenBufferInfo.Call( 286 uintptr(hConsoleOutput), 287 uintptr(unsafe.Pointer(&csbi))) 288 if ret == 0 { 289 return nil 290 } 291 return &csbi 292 } 293 294 func SetConsoleTextAttribute(hConsoleOutput HANDLE, wAttributes uint16) bool { 295 ret, _, _ := procSetConsoleTextAttribute.Call( 296 uintptr(hConsoleOutput), 297 uintptr(wAttributes)) 298 return ret != 0 299 } 300 301 func GetDiskFreeSpaceEx(dirName string) (r bool, 302 freeBytesAvailable, totalNumberOfBytes, totalNumberOfFreeBytes uint64) { 303 ret, _, _ := procGetDiskFreeSpaceEx.Call( 304 uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(dirName))), 305 uintptr(unsafe.Pointer(&freeBytesAvailable)), 306 uintptr(unsafe.Pointer(&totalNumberOfBytes)), 307 uintptr(unsafe.Pointer(&totalNumberOfFreeBytes))) 308 return ret != 0, 309 freeBytesAvailable, totalNumberOfBytes, totalNumberOfFreeBytes 310 } 311 312 func GetSystemTime() *SYSTEMTIME { 313 var time SYSTEMTIME 314 procGetSystemTime.Call( 315 uintptr(unsafe.Pointer(&time))) 316 return &time 317 } 318 319 func SetSystemTime(time *SYSTEMTIME) bool { 320 ret, _, _ := procSetSystemTime.Call( 321 uintptr(unsafe.Pointer(time))) 322 return ret != 0 323 } 324 325 func GetLogicalDriveStrings(nBufferLength uint32, lpBuffer *uint16) uint32 { 326 ret, _, _ := procGetLogicalDriveStrings.Call( 327 uintptr(nBufferLength), 328 uintptr(unsafe.Pointer(lpBuffer)), 329 0) 330 331 return uint32(ret) 332 }