mirror of
https://github.com/yv1ing/ShotRDP.git
synced 2025-09-16 15:10:57 +08:00
2367 lines
73 KiB
Go
2367 lines
73 KiB
Go
// This file was automatically generated by https://github.com/kbinani/win/blob/generator/internal/cmd/gen/gen.go
|
|
// go run internal/cmd/gen/gen.go
|
|
|
|
// +build windows
|
|
|
|
package win
|
|
|
|
import (
|
|
"syscall"
|
|
"unsafe"
|
|
)
|
|
|
|
var (
|
|
// Library
|
|
libshlwapi uintptr
|
|
|
|
// Functions
|
|
assocCreate uintptr
|
|
assocGetPerceivedType uintptr
|
|
assocIsDangerous uintptr
|
|
assocQueryKey uintptr
|
|
assocQueryStringByKey uintptr
|
|
assocQueryString uintptr
|
|
chrCmpI uintptr
|
|
colorAdjustLuma uintptr
|
|
colorHLSToRGB uintptr
|
|
colorRGBToHLS uintptr
|
|
connectToConnectionPoint uintptr
|
|
getAcceptLanguages uintptr
|
|
getMenuPosFromID uintptr
|
|
hashData uintptr
|
|
iStream_Reset uintptr
|
|
iStream_Size uintptr
|
|
iUnknown_AtomicRelease uintptr
|
|
iUnknown_GetSite uintptr
|
|
iUnknown_GetWindow uintptr
|
|
iUnknown_QueryService uintptr
|
|
iUnknown_Set uintptr
|
|
iUnknown_SetSite uintptr
|
|
intlStrEqWorker uintptr
|
|
isCharSpace uintptr
|
|
isInternetESCEnabled uintptr
|
|
isOS uintptr
|
|
mLFreeLibrary uintptr
|
|
mLLoadLibrary uintptr
|
|
parseURL uintptr
|
|
pathAddBackslash uintptr
|
|
pathAddExtension uintptr
|
|
pathAppend uintptr
|
|
pathBuildRoot uintptr
|
|
pathCanonicalize uintptr
|
|
pathCombine uintptr
|
|
pathCommonPrefix uintptr
|
|
pathCompactPathEx uintptr
|
|
pathCompactPath uintptr
|
|
pathCreateFromUrlAlloc uintptr
|
|
pathCreateFromUrl uintptr
|
|
pathFileExists uintptr
|
|
pathFindExtension uintptr
|
|
pathFindFileName uintptr
|
|
pathFindNextComponent uintptr
|
|
pathFindOnPath uintptr
|
|
pathFindSuffixArray uintptr
|
|
pathGetArgs uintptr
|
|
pathGetCharType uintptr
|
|
pathGetDriveNumber uintptr
|
|
pathIsContentType uintptr
|
|
pathIsDirectoryEmpty uintptr
|
|
pathIsDirectory uintptr
|
|
pathIsFileSpec uintptr
|
|
pathIsLFNFileSpec uintptr
|
|
pathIsNetworkPath uintptr
|
|
pathIsPrefix uintptr
|
|
pathIsRelative uintptr
|
|
pathIsRoot uintptr
|
|
pathIsSameRoot uintptr
|
|
pathIsSystemFolder uintptr
|
|
pathIsUNCServerShare uintptr
|
|
pathIsUNCServer uintptr
|
|
pathIsUNC uintptr
|
|
pathIsURL uintptr
|
|
pathMakePretty uintptr
|
|
pathMakeSystemFolder uintptr
|
|
pathMatchSpec uintptr
|
|
pathParseIconLocation uintptr
|
|
pathQuoteSpaces uintptr
|
|
pathRelativePathTo uintptr
|
|
pathRemoveArgs uintptr
|
|
pathRemoveBackslash uintptr
|
|
pathRemoveBlanks uintptr
|
|
pathRemoveExtension uintptr
|
|
pathRemoveFileSpec uintptr
|
|
pathRenameExtension uintptr
|
|
pathSearchAndQualify uintptr
|
|
pathSetDlgItemPath uintptr
|
|
pathSkipRoot uintptr
|
|
pathStripPath uintptr
|
|
pathStripToRoot uintptr
|
|
pathUnExpandEnvStrings uintptr
|
|
pathUndecorate uintptr
|
|
pathUnmakeSystemFolder uintptr
|
|
pathUnquoteSpaces uintptr
|
|
qISearch uintptr
|
|
sHAllocShared uintptr
|
|
sHAnsiToAnsi uintptr
|
|
sHAnsiToUnicode uintptr
|
|
sHAutoComplete uintptr
|
|
sHCopyKey uintptr
|
|
sHCreateShellPalette uintptr
|
|
sHCreateStreamOnFileEx uintptr
|
|
sHCreateStreamOnFile uintptr
|
|
sHCreateStreamWrapper uintptr
|
|
sHCreateThread uintptr
|
|
sHCreateThreadRef uintptr
|
|
sHDeleteEmptyKey uintptr
|
|
sHDeleteKey uintptr
|
|
sHDeleteOrphanKey uintptr
|
|
sHDeleteValue uintptr
|
|
sHEnumKeyEx uintptr
|
|
sHEnumValue uintptr
|
|
sHFormatDateTime uintptr
|
|
sHFreeShared uintptr
|
|
sHGetInverseCMAP uintptr
|
|
sHGetThreadRef uintptr
|
|
sHGetValue uintptr
|
|
sHGetViewStatePropertyBag uintptr
|
|
sHIsChildOrSelf uintptr
|
|
sHIsLowMemoryMachine uintptr
|
|
sHLoadIndirectString uintptr
|
|
sHLockShared uintptr
|
|
sHMessageBoxCheck uintptr
|
|
sHQueryInfoKey uintptr
|
|
sHQueryValueEx uintptr
|
|
sHRegCloseUSKey uintptr
|
|
sHRegCreateUSKey uintptr
|
|
sHRegDeleteEmptyUSKey uintptr
|
|
sHRegDeleteUSValue uintptr
|
|
sHRegDuplicateHKey uintptr
|
|
sHRegEnumUSKey uintptr
|
|
sHRegEnumUSValue uintptr
|
|
sHRegGetBoolUSValue uintptr
|
|
sHRegGetIntW uintptr
|
|
sHRegGetPath uintptr
|
|
sHRegGetUSValue uintptr
|
|
sHRegOpenUSKey uintptr
|
|
sHRegQueryInfoUSKey uintptr
|
|
sHRegQueryUSValue uintptr
|
|
sHRegSetPath uintptr
|
|
sHRegSetUSValue uintptr
|
|
sHRegWriteUSValue uintptr
|
|
sHRegisterValidateTemplate uintptr
|
|
sHReleaseThreadRef uintptr
|
|
sHSendMessageBroadcast uintptr
|
|
sHSetThreadRef uintptr
|
|
sHSetValue uintptr
|
|
sHSkipJunction uintptr
|
|
sHStrDup uintptr
|
|
sHStripMneumonic uintptr
|
|
sHUnicodeToAnsi uintptr
|
|
sHUnicodeToUnicode uintptr
|
|
sHUnlockShared uintptr
|
|
strCSpnI uintptr
|
|
strCSpn uintptr
|
|
strCatBuff uintptr
|
|
strCatChainW uintptr
|
|
strCatW uintptr
|
|
strChrI uintptr
|
|
strChrNW uintptr
|
|
strChr uintptr
|
|
strCmpC uintptr
|
|
strCmpIC uintptr
|
|
strCmpIW uintptr
|
|
strCmpLogicalW uintptr
|
|
strCmpNC uintptr
|
|
strCmpNIC uintptr
|
|
strCmpNI uintptr
|
|
strCmpN uintptr
|
|
strCmpW uintptr
|
|
strCpyNW uintptr
|
|
strCpyW uintptr
|
|
strDup uintptr
|
|
strFormatByteSize64A uintptr
|
|
strFormatByteSize uintptr
|
|
strFormatKBSize uintptr
|
|
strFromTimeInterval uintptr
|
|
strIsIntlEqual uintptr
|
|
strNCat uintptr
|
|
strPBrk uintptr
|
|
strRChrI uintptr
|
|
strRChr uintptr
|
|
strRStrI uintptr
|
|
strRetToBSTR uintptr
|
|
strRetToBuf uintptr
|
|
strRetToStr uintptr
|
|
strSpn uintptr
|
|
strStrI uintptr
|
|
strStrNIW uintptr
|
|
strStrNW uintptr
|
|
strStr uintptr
|
|
strToInt64Ex uintptr
|
|
strToIntEx uintptr
|
|
strToInt uintptr
|
|
strTrim uintptr
|
|
urlApplyScheme uintptr
|
|
urlCanonicalize uintptr
|
|
urlCombine uintptr
|
|
urlCompare uintptr
|
|
urlCreateFromPath uintptr
|
|
urlEscape uintptr
|
|
urlFixupW uintptr
|
|
urlGetLocation uintptr
|
|
urlGetPart uintptr
|
|
urlHash uintptr
|
|
urlIsNoHistory uintptr
|
|
urlIsOpaque uintptr
|
|
urlIs uintptr
|
|
urlUnescape uintptr
|
|
whichPlatform uintptr
|
|
)
|
|
|
|
func init() {
|
|
// Library
|
|
libshlwapi = doLoadLibrary("shlwapi.dll")
|
|
|
|
// Functions
|
|
assocCreate = doGetProcAddress(libshlwapi, "AssocCreate")
|
|
assocGetPerceivedType = doGetProcAddress(libshlwapi, "AssocGetPerceivedType")
|
|
assocIsDangerous = doGetProcAddress(libshlwapi, "AssocIsDangerous")
|
|
assocQueryKey = doGetProcAddress(libshlwapi, "AssocQueryKeyW")
|
|
assocQueryStringByKey = doGetProcAddress(libshlwapi, "AssocQueryStringByKeyW")
|
|
assocQueryString = doGetProcAddress(libshlwapi, "AssocQueryStringW")
|
|
chrCmpI = doGetProcAddress(libshlwapi, "ChrCmpIW")
|
|
colorAdjustLuma = doGetProcAddress(libshlwapi, "ColorAdjustLuma")
|
|
colorHLSToRGB = doGetProcAddress(libshlwapi, "ColorHLSToRGB")
|
|
colorRGBToHLS = doGetProcAddress(libshlwapi, "ColorRGBToHLS")
|
|
connectToConnectionPoint = doGetProcAddress(libshlwapi, "ConnectToConnectionPoint")
|
|
getAcceptLanguages = doGetProcAddress(libshlwapi, "GetAcceptLanguagesW")
|
|
getMenuPosFromID = doGetProcAddress(libshlwapi, "GetMenuPosFromID")
|
|
hashData = doGetProcAddress(libshlwapi, "HashData")
|
|
iStream_Reset = doGetProcAddress(libshlwapi, "IStream_Reset")
|
|
iStream_Size = doGetProcAddress(libshlwapi, "IStream_Size")
|
|
iUnknown_AtomicRelease = doGetProcAddress(libshlwapi, "IUnknown_AtomicRelease")
|
|
iUnknown_GetSite = doGetProcAddress(libshlwapi, "IUnknown_GetSite")
|
|
iUnknown_GetWindow = doGetProcAddress(libshlwapi, "IUnknown_GetWindow")
|
|
iUnknown_QueryService = doGetProcAddress(libshlwapi, "IUnknown_QueryService")
|
|
iUnknown_Set = doGetProcAddress(libshlwapi, "IUnknown_Set")
|
|
iUnknown_SetSite = doGetProcAddress(libshlwapi, "IUnknown_SetSite")
|
|
intlStrEqWorker = doGetProcAddress(libshlwapi, "IntlStrEqWorkerW")
|
|
isCharSpace = doGetProcAddress(libshlwapi, "IsCharSpaceW")
|
|
isInternetESCEnabled = doGetProcAddress(libshlwapi, "IsInternetESCEnabled")
|
|
isOS = doGetProcAddress(libshlwapi, "IsOS")
|
|
mLFreeLibrary = doGetProcAddress(libshlwapi, "MLFreeLibrary")
|
|
mLLoadLibrary = doGetProcAddress(libshlwapi, "MLLoadLibraryW")
|
|
parseURL = doGetProcAddress(libshlwapi, "ParseURLW")
|
|
pathAddBackslash = doGetProcAddress(libshlwapi, "PathAddBackslashW")
|
|
pathAddExtension = doGetProcAddress(libshlwapi, "PathAddExtensionW")
|
|
pathAppend = doGetProcAddress(libshlwapi, "PathAppendW")
|
|
pathBuildRoot = doGetProcAddress(libshlwapi, "PathBuildRootW")
|
|
pathCanonicalize = doGetProcAddress(libshlwapi, "PathCanonicalizeW")
|
|
pathCombine = doGetProcAddress(libshlwapi, "PathCombineW")
|
|
pathCommonPrefix = doGetProcAddress(libshlwapi, "PathCommonPrefixW")
|
|
pathCompactPathEx = doGetProcAddress(libshlwapi, "PathCompactPathExW")
|
|
pathCompactPath = doGetProcAddress(libshlwapi, "PathCompactPathW")
|
|
pathCreateFromUrlAlloc = doGetProcAddress(libshlwapi, "PathCreateFromUrlAlloc")
|
|
pathCreateFromUrl = doGetProcAddress(libshlwapi, "PathCreateFromUrlW")
|
|
pathFileExists = doGetProcAddress(libshlwapi, "PathFileExistsW")
|
|
pathFindExtension = doGetProcAddress(libshlwapi, "PathFindExtensionW")
|
|
pathFindFileName = doGetProcAddress(libshlwapi, "PathFindFileNameW")
|
|
pathFindNextComponent = doGetProcAddress(libshlwapi, "PathFindNextComponentW")
|
|
pathFindOnPath = doGetProcAddress(libshlwapi, "PathFindOnPathW")
|
|
pathFindSuffixArray = doGetProcAddress(libshlwapi, "PathFindSuffixArrayW")
|
|
pathGetArgs = doGetProcAddress(libshlwapi, "PathGetArgsW")
|
|
pathGetCharType = doGetProcAddress(libshlwapi, "PathGetCharTypeW")
|
|
pathGetDriveNumber = doGetProcAddress(libshlwapi, "PathGetDriveNumberW")
|
|
pathIsContentType = doGetProcAddress(libshlwapi, "PathIsContentTypeW")
|
|
pathIsDirectoryEmpty = doGetProcAddress(libshlwapi, "PathIsDirectoryEmptyW")
|
|
pathIsDirectory = doGetProcAddress(libshlwapi, "PathIsDirectoryW")
|
|
pathIsFileSpec = doGetProcAddress(libshlwapi, "PathIsFileSpecW")
|
|
pathIsLFNFileSpec = doGetProcAddress(libshlwapi, "PathIsLFNFileSpecW")
|
|
pathIsNetworkPath = doGetProcAddress(libshlwapi, "PathIsNetworkPathW")
|
|
pathIsPrefix = doGetProcAddress(libshlwapi, "PathIsPrefixW")
|
|
pathIsRelative = doGetProcAddress(libshlwapi, "PathIsRelativeW")
|
|
pathIsRoot = doGetProcAddress(libshlwapi, "PathIsRootW")
|
|
pathIsSameRoot = doGetProcAddress(libshlwapi, "PathIsSameRootW")
|
|
pathIsSystemFolder = doGetProcAddress(libshlwapi, "PathIsSystemFolderW")
|
|
pathIsUNCServerShare = doGetProcAddress(libshlwapi, "PathIsUNCServerShareW")
|
|
pathIsUNCServer = doGetProcAddress(libshlwapi, "PathIsUNCServerW")
|
|
pathIsUNC = doGetProcAddress(libshlwapi, "PathIsUNCW")
|
|
pathIsURL = doGetProcAddress(libshlwapi, "PathIsURLW")
|
|
pathMakePretty = doGetProcAddress(libshlwapi, "PathMakePrettyW")
|
|
pathMakeSystemFolder = doGetProcAddress(libshlwapi, "PathMakeSystemFolderW")
|
|
pathMatchSpec = doGetProcAddress(libshlwapi, "PathMatchSpecW")
|
|
pathParseIconLocation = doGetProcAddress(libshlwapi, "PathParseIconLocationW")
|
|
pathQuoteSpaces = doGetProcAddress(libshlwapi, "PathQuoteSpacesW")
|
|
pathRelativePathTo = doGetProcAddress(libshlwapi, "PathRelativePathToW")
|
|
pathRemoveArgs = doGetProcAddress(libshlwapi, "PathRemoveArgsW")
|
|
pathRemoveBackslash = doGetProcAddress(libshlwapi, "PathRemoveBackslashW")
|
|
pathRemoveBlanks = doGetProcAddress(libshlwapi, "PathRemoveBlanksW")
|
|
pathRemoveExtension = doGetProcAddress(libshlwapi, "PathRemoveExtensionW")
|
|
pathRemoveFileSpec = doGetProcAddress(libshlwapi, "PathRemoveFileSpecW")
|
|
pathRenameExtension = doGetProcAddress(libshlwapi, "PathRenameExtensionW")
|
|
pathSearchAndQualify = doGetProcAddress(libshlwapi, "PathSearchAndQualifyW")
|
|
pathSetDlgItemPath = doGetProcAddress(libshlwapi, "PathSetDlgItemPathW")
|
|
pathSkipRoot = doGetProcAddress(libshlwapi, "PathSkipRootW")
|
|
pathStripPath = doGetProcAddress(libshlwapi, "PathStripPathW")
|
|
pathStripToRoot = doGetProcAddress(libshlwapi, "PathStripToRootW")
|
|
pathUnExpandEnvStrings = doGetProcAddress(libshlwapi, "PathUnExpandEnvStringsW")
|
|
pathUndecorate = doGetProcAddress(libshlwapi, "PathUndecorateW")
|
|
pathUnmakeSystemFolder = doGetProcAddress(libshlwapi, "PathUnmakeSystemFolderW")
|
|
pathUnquoteSpaces = doGetProcAddress(libshlwapi, "PathUnquoteSpacesW")
|
|
qISearch = doGetProcAddress(libshlwapi, "QISearch")
|
|
sHAllocShared = doGetProcAddress(libshlwapi, "SHAllocShared")
|
|
sHAnsiToAnsi = doGetProcAddress(libshlwapi, "SHAnsiToAnsi")
|
|
sHAnsiToUnicode = doGetProcAddress(libshlwapi, "SHAnsiToUnicode")
|
|
sHAutoComplete = doGetProcAddress(libshlwapi, "SHAutoComplete")
|
|
sHCopyKey = doGetProcAddress(libshlwapi, "SHCopyKeyW")
|
|
sHCreateShellPalette = doGetProcAddress(libshlwapi, "SHCreateShellPalette")
|
|
sHCreateStreamOnFileEx = doGetProcAddress(libshlwapi, "SHCreateStreamOnFileEx")
|
|
sHCreateStreamOnFile = doGetProcAddress(libshlwapi, "SHCreateStreamOnFileW")
|
|
sHCreateStreamWrapper = doGetProcAddress(libshlwapi, "SHCreateStreamWrapper")
|
|
sHCreateThread = doGetProcAddress(libshlwapi, "SHCreateThread")
|
|
sHCreateThreadRef = doGetProcAddress(libshlwapi, "SHCreateThreadRef")
|
|
sHDeleteEmptyKey = doGetProcAddress(libshlwapi, "SHDeleteEmptyKeyW")
|
|
sHDeleteKey = doGetProcAddress(libshlwapi, "SHDeleteKeyW")
|
|
sHDeleteOrphanKey = doGetProcAddress(libshlwapi, "SHDeleteOrphanKeyW")
|
|
sHDeleteValue = doGetProcAddress(libshlwapi, "SHDeleteValueW")
|
|
sHEnumKeyEx = doGetProcAddress(libshlwapi, "SHEnumKeyExW")
|
|
sHEnumValue = doGetProcAddress(libshlwapi, "SHEnumValueW")
|
|
sHFormatDateTime = doGetProcAddress(libshlwapi, "SHFormatDateTimeW")
|
|
sHFreeShared = doGetProcAddress(libshlwapi, "SHFreeShared")
|
|
sHGetInverseCMAP = doGetProcAddress(libshlwapi, "SHGetInverseCMAP")
|
|
sHGetThreadRef = doGetProcAddress(libshlwapi, "SHGetThreadRef")
|
|
sHGetValue = doGetProcAddress(libshlwapi, "SHGetValueW")
|
|
sHGetViewStatePropertyBag = doGetProcAddress(libshlwapi, "SHGetViewStatePropertyBag")
|
|
sHIsChildOrSelf = doGetProcAddress(libshlwapi, "SHIsChildOrSelf")
|
|
sHIsLowMemoryMachine = doGetProcAddress(libshlwapi, "SHIsLowMemoryMachine")
|
|
sHLoadIndirectString = doGetProcAddress(libshlwapi, "SHLoadIndirectString")
|
|
sHLockShared = doGetProcAddress(libshlwapi, "SHLockShared")
|
|
sHMessageBoxCheck = doGetProcAddress(libshlwapi, "SHMessageBoxCheckW")
|
|
sHQueryInfoKey = doGetProcAddress(libshlwapi, "SHQueryInfoKeyW")
|
|
sHQueryValueEx = doGetProcAddress(libshlwapi, "SHQueryValueExW")
|
|
sHRegCloseUSKey = doGetProcAddress(libshlwapi, "SHRegCloseUSKey")
|
|
sHRegCreateUSKey = doGetProcAddress(libshlwapi, "SHRegCreateUSKeyW")
|
|
sHRegDeleteEmptyUSKey = doGetProcAddress(libshlwapi, "SHRegDeleteEmptyUSKeyW")
|
|
sHRegDeleteUSValue = doGetProcAddress(libshlwapi, "SHRegDeleteUSValueW")
|
|
sHRegDuplicateHKey = doGetProcAddress(libshlwapi, "SHRegDuplicateHKey")
|
|
sHRegEnumUSKey = doGetProcAddress(libshlwapi, "SHRegEnumUSKeyW")
|
|
sHRegEnumUSValue = doGetProcAddress(libshlwapi, "SHRegEnumUSValueW")
|
|
sHRegGetBoolUSValue = doGetProcAddress(libshlwapi, "SHRegGetBoolUSValueW")
|
|
sHRegGetIntW = doGetProcAddress(libshlwapi, "SHRegGetIntW")
|
|
sHRegGetPath = doGetProcAddress(libshlwapi, "SHRegGetPathW")
|
|
sHRegGetUSValue = doGetProcAddress(libshlwapi, "SHRegGetUSValueW")
|
|
sHRegOpenUSKey = doGetProcAddress(libshlwapi, "SHRegOpenUSKeyW")
|
|
sHRegQueryInfoUSKey = doGetProcAddress(libshlwapi, "SHRegQueryInfoUSKeyW")
|
|
sHRegQueryUSValue = doGetProcAddress(libshlwapi, "SHRegQueryUSValueW")
|
|
sHRegSetPath = doGetProcAddress(libshlwapi, "SHRegSetPathW")
|
|
sHRegSetUSValue = doGetProcAddress(libshlwapi, "SHRegSetUSValueW")
|
|
sHRegWriteUSValue = doGetProcAddress(libshlwapi, "SHRegWriteUSValueW")
|
|
sHRegisterValidateTemplate = doGetProcAddress(libshlwapi, "SHRegisterValidateTemplate")
|
|
sHReleaseThreadRef = doGetProcAddress(libshlwapi, "SHReleaseThreadRef")
|
|
sHSendMessageBroadcast = doGetProcAddress(libshlwapi, "SHSendMessageBroadcastW")
|
|
sHSetThreadRef = doGetProcAddress(libshlwapi, "SHSetThreadRef")
|
|
sHSetValue = doGetProcAddress(libshlwapi, "SHSetValueW")
|
|
sHSkipJunction = doGetProcAddress(libshlwapi, "SHSkipJunction")
|
|
sHStrDup = doGetProcAddress(libshlwapi, "SHStrDupW")
|
|
sHStripMneumonic = doGetProcAddress(libshlwapi, "SHStripMneumonicW")
|
|
sHUnicodeToAnsi = doGetProcAddress(libshlwapi, "SHUnicodeToAnsi")
|
|
sHUnicodeToUnicode = doGetProcAddress(libshlwapi, "SHUnicodeToUnicode")
|
|
sHUnlockShared = doGetProcAddress(libshlwapi, "SHUnlockShared")
|
|
strCSpnI = doGetProcAddress(libshlwapi, "StrCSpnIW")
|
|
strCSpn = doGetProcAddress(libshlwapi, "StrCSpnW")
|
|
strCatBuff = doGetProcAddress(libshlwapi, "StrCatBuffW")
|
|
strCatChainW = doGetProcAddress(libshlwapi, "StrCatChainW")
|
|
strCatW = doGetProcAddress(libshlwapi, "StrCatW")
|
|
strChrI = doGetProcAddress(libshlwapi, "StrChrIW")
|
|
strChrNW = doGetProcAddress(libshlwapi, "StrChrNW")
|
|
strChr = doGetProcAddress(libshlwapi, "StrChrW")
|
|
strCmpC = doGetProcAddress(libshlwapi, "StrCmpCW")
|
|
strCmpIC = doGetProcAddress(libshlwapi, "StrCmpICW")
|
|
strCmpIW = doGetProcAddress(libshlwapi, "StrCmpIW")
|
|
strCmpLogicalW = doGetProcAddress(libshlwapi, "StrCmpLogicalW")
|
|
strCmpNC = doGetProcAddress(libshlwapi, "StrCmpNCW")
|
|
strCmpNIC = doGetProcAddress(libshlwapi, "StrCmpNICW")
|
|
strCmpNI = doGetProcAddress(libshlwapi, "StrCmpNIW")
|
|
strCmpN = doGetProcAddress(libshlwapi, "StrCmpNW")
|
|
strCmpW = doGetProcAddress(libshlwapi, "StrCmpW")
|
|
strCpyNW = doGetProcAddress(libshlwapi, "StrCpyNW")
|
|
strCpyW = doGetProcAddress(libshlwapi, "StrCpyW")
|
|
strDup = doGetProcAddress(libshlwapi, "StrDupW")
|
|
strFormatByteSize64A = doGetProcAddress(libshlwapi, "StrFormatByteSize64A")
|
|
strFormatByteSize = doGetProcAddress(libshlwapi, "StrFormatByteSizeW")
|
|
strFormatKBSize = doGetProcAddress(libshlwapi, "StrFormatKBSizeW")
|
|
strFromTimeInterval = doGetProcAddress(libshlwapi, "StrFromTimeIntervalW")
|
|
strIsIntlEqual = doGetProcAddress(libshlwapi, "StrIsIntlEqualW")
|
|
strNCat = doGetProcAddress(libshlwapi, "StrNCatW")
|
|
strPBrk = doGetProcAddress(libshlwapi, "StrPBrkW")
|
|
strRChrI = doGetProcAddress(libshlwapi, "StrRChrIW")
|
|
strRChr = doGetProcAddress(libshlwapi, "StrRChrW")
|
|
strRStrI = doGetProcAddress(libshlwapi, "StrRStrIW")
|
|
strRetToBSTR = doGetProcAddress(libshlwapi, "StrRetToBSTR")
|
|
strRetToBuf = doGetProcAddress(libshlwapi, "StrRetToBufW")
|
|
strRetToStr = doGetProcAddress(libshlwapi, "StrRetToStrW")
|
|
strSpn = doGetProcAddress(libshlwapi, "StrSpnW")
|
|
strStrI = doGetProcAddress(libshlwapi, "StrStrIW")
|
|
strStrNIW = doGetProcAddress(libshlwapi, "StrStrNIW")
|
|
strStrNW = doGetProcAddress(libshlwapi, "StrStrNW")
|
|
strStr = doGetProcAddress(libshlwapi, "StrStrW")
|
|
strToInt64Ex = doGetProcAddress(libshlwapi, "StrToInt64ExW")
|
|
strToIntEx = doGetProcAddress(libshlwapi, "StrToIntExW")
|
|
strToInt = doGetProcAddress(libshlwapi, "StrToIntW")
|
|
strTrim = doGetProcAddress(libshlwapi, "StrTrimW")
|
|
urlApplyScheme = doGetProcAddress(libshlwapi, "UrlApplySchemeW")
|
|
urlCanonicalize = doGetProcAddress(libshlwapi, "UrlCanonicalizeW")
|
|
urlCombine = doGetProcAddress(libshlwapi, "UrlCombineW")
|
|
urlCompare = doGetProcAddress(libshlwapi, "UrlCompareW")
|
|
urlCreateFromPath = doGetProcAddress(libshlwapi, "UrlCreateFromPathW")
|
|
urlEscape = doGetProcAddress(libshlwapi, "UrlEscapeW")
|
|
urlFixupW = doGetProcAddress(libshlwapi, "UrlFixupW")
|
|
urlGetLocation = doGetProcAddress(libshlwapi, "UrlGetLocationW")
|
|
urlGetPart = doGetProcAddress(libshlwapi, "UrlGetPartW")
|
|
urlHash = doGetProcAddress(libshlwapi, "UrlHashW")
|
|
urlIsNoHistory = doGetProcAddress(libshlwapi, "UrlIsNoHistoryW")
|
|
urlIsOpaque = doGetProcAddress(libshlwapi, "UrlIsOpaqueW")
|
|
urlIs = doGetProcAddress(libshlwapi, "UrlIsW")
|
|
urlUnescape = doGetProcAddress(libshlwapi, "UrlUnescapeW")
|
|
whichPlatform = doGetProcAddress(libshlwapi, "WhichPlatform")
|
|
}
|
|
|
|
func AssocCreate(clsid CLSID, refiid REFIID, lpInterface uintptr) HRESULT {
|
|
ret1 := syscall6(assocCreate, 6,
|
|
uintptr(clsid.Data1),
|
|
uintptr((uint32(clsid.Data2)<<16)|uint32(clsid.Data3)),
|
|
uintptr((uint32(clsid.Data4[0])<<24)|(uint32(clsid.Data4[1]<<16))|(uint32(clsid.Data4[2]<<8))|uint32(clsid.Data4[3])),
|
|
uintptr((uint32(clsid.Data4[4])<<24)|(uint32(clsid.Data4[5]<<16))|(uint32(clsid.Data4[6]<<8))|uint32(clsid.Data4[7])),
|
|
uintptr(unsafe.Pointer(refiid)),
|
|
lpInterface)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func AssocGetPerceivedType(lpszExt string, lpType *PERCEIVED, lpFlag *int32, lppszType *LPWSTR) HRESULT {
|
|
lpszExtStr := unicode16FromString(lpszExt)
|
|
ret1 := syscall6(assocGetPerceivedType, 4,
|
|
uintptr(unsafe.Pointer(&lpszExtStr[0])),
|
|
uintptr(unsafe.Pointer(lpType)),
|
|
uintptr(unsafe.Pointer(lpFlag)),
|
|
uintptr(unsafe.Pointer(lppszType)),
|
|
0,
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func AssocIsDangerous(lpszAssoc string) bool {
|
|
lpszAssocStr := unicode16FromString(lpszAssoc)
|
|
ret1 := syscall3(assocIsDangerous, 1,
|
|
uintptr(unsafe.Pointer(&lpszAssocStr[0])),
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func AssocQueryKey(cfFlags ASSOCF, assockey ASSOCKEY, pszAssoc string, pszExtra string, phkeyOut *HKEY) HRESULT {
|
|
pszAssocStr := unicode16FromString(pszAssoc)
|
|
pszExtraStr := unicode16FromString(pszExtra)
|
|
ret1 := syscall6(assocQueryKey, 5,
|
|
uintptr(cfFlags),
|
|
uintptr(assockey),
|
|
uintptr(unsafe.Pointer(&pszAssocStr[0])),
|
|
uintptr(unsafe.Pointer(&pszExtraStr[0])),
|
|
uintptr(unsafe.Pointer(phkeyOut)),
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func AssocQueryStringByKey(cfFlags ASSOCF, str ASSOCSTR, hkAssoc HKEY, pszExtra string, pszOut LPWSTR, pcchOut *uint32) HRESULT {
|
|
pszExtraStr := unicode16FromString(pszExtra)
|
|
ret1 := syscall6(assocQueryStringByKey, 6,
|
|
uintptr(cfFlags),
|
|
uintptr(str),
|
|
uintptr(hkAssoc),
|
|
uintptr(unsafe.Pointer(&pszExtraStr[0])),
|
|
uintptr(unsafe.Pointer(pszOut)),
|
|
uintptr(unsafe.Pointer(pcchOut)))
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func AssocQueryString(cfFlags ASSOCF, str ASSOCSTR, pszAssoc string, pszExtra string, pszOut LPWSTR, pcchOut *uint32) HRESULT {
|
|
pszAssocStr := unicode16FromString(pszAssoc)
|
|
pszExtraStr := unicode16FromString(pszExtra)
|
|
ret1 := syscall6(assocQueryString, 6,
|
|
uintptr(cfFlags),
|
|
uintptr(str),
|
|
uintptr(unsafe.Pointer(&pszAssocStr[0])),
|
|
uintptr(unsafe.Pointer(&pszExtraStr[0])),
|
|
uintptr(unsafe.Pointer(pszOut)),
|
|
uintptr(unsafe.Pointer(pcchOut)))
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func ChrCmpI(ch1 WCHAR, ch2 WCHAR) bool {
|
|
ret1 := syscall3(chrCmpI, 2,
|
|
uintptr(ch1),
|
|
uintptr(ch2),
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func ColorAdjustLuma(cRGB COLORREF, dwLuma int32, bUnknown bool) COLORREF {
|
|
ret1 := syscall3(colorAdjustLuma, 3,
|
|
uintptr(cRGB),
|
|
uintptr(dwLuma),
|
|
getUintptrFromBool(bUnknown))
|
|
return COLORREF(ret1)
|
|
}
|
|
|
|
func ColorHLSToRGB(wHue WORD, wLuminosity WORD, wSaturation WORD) COLORREF {
|
|
ret1 := syscall3(colorHLSToRGB, 3,
|
|
uintptr(wHue),
|
|
uintptr(wLuminosity),
|
|
uintptr(wSaturation))
|
|
return COLORREF(ret1)
|
|
}
|
|
|
|
func ColorRGBToHLS(cRGB COLORREF, pwHue *uint16, pwLuminance *uint16, pwSaturation *uint16) {
|
|
syscall6(colorRGBToHLS, 4,
|
|
uintptr(cRGB),
|
|
uintptr(unsafe.Pointer(pwHue)),
|
|
uintptr(unsafe.Pointer(pwLuminance)),
|
|
uintptr(unsafe.Pointer(pwSaturation)),
|
|
0,
|
|
0)
|
|
}
|
|
|
|
func ConnectToConnectionPoint(lpUnkSink *IUnknown, riid REFIID, fConnect bool, lpUnknown *IUnknown, lpCookie *uint32, lppCP **IConnectionPoint) HRESULT {
|
|
ret1 := syscall6(connectToConnectionPoint, 6,
|
|
uintptr(unsafe.Pointer(lpUnkSink)),
|
|
uintptr(unsafe.Pointer(riid)),
|
|
getUintptrFromBool(fConnect),
|
|
uintptr(unsafe.Pointer(lpUnknown)),
|
|
uintptr(unsafe.Pointer(lpCookie)),
|
|
uintptr(unsafe.Pointer(lppCP)))
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func GetAcceptLanguages(langbuf LPWSTR, buflen *uint32) HRESULT {
|
|
ret1 := syscall3(getAcceptLanguages, 2,
|
|
uintptr(unsafe.Pointer(langbuf)),
|
|
uintptr(unsafe.Pointer(buflen)),
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func GetMenuPosFromID(hMenu HMENU, wID UINT) INT {
|
|
ret1 := syscall3(getMenuPosFromID, 2,
|
|
uintptr(hMenu),
|
|
uintptr(wID),
|
|
0)
|
|
return INT(ret1)
|
|
}
|
|
|
|
func HashData(lpSrc /*const*/ *byte, nSrcLen DWORD, lpDest *byte, nDestLen DWORD) HRESULT {
|
|
ret1 := syscall6(hashData, 4,
|
|
uintptr(unsafe.Pointer(lpSrc)),
|
|
uintptr(nSrcLen),
|
|
uintptr(unsafe.Pointer(lpDest)),
|
|
uintptr(nDestLen),
|
|
0,
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func IStream_Reset(lpStream *IStream) HRESULT {
|
|
ret1 := syscall3(iStream_Reset, 1,
|
|
uintptr(unsafe.Pointer(lpStream)),
|
|
0,
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func IStream_Size(lpStream *IStream, lpulSize *ULARGE_INTEGER) HRESULT {
|
|
ret1 := syscall3(iStream_Size, 2,
|
|
uintptr(unsafe.Pointer(lpStream)),
|
|
uintptr(unsafe.Pointer(lpulSize)),
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func IUnknown_AtomicRelease(lpUnknown **IUnknown) {
|
|
syscall3(iUnknown_AtomicRelease, 1,
|
|
uintptr(unsafe.Pointer(lpUnknown)),
|
|
0,
|
|
0)
|
|
}
|
|
|
|
func IUnknown_GetSite(lpUnknown LPUNKNOWN, iid REFIID, lppSite *PVOID) HRESULT {
|
|
ret1 := syscall3(iUnknown_GetSite, 3,
|
|
uintptr(unsafe.Pointer(lpUnknown)),
|
|
uintptr(unsafe.Pointer(iid)),
|
|
uintptr(unsafe.Pointer(lppSite)))
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func IUnknown_GetWindow(lpUnknown *IUnknown, lphWnd *HWND) HRESULT {
|
|
ret1 := syscall3(iUnknown_GetWindow, 2,
|
|
uintptr(unsafe.Pointer(lpUnknown)),
|
|
uintptr(unsafe.Pointer(lphWnd)),
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func IUnknown_QueryService(unnamed0 *IUnknown, unnamed1 REFGUID, unnamed2 REFIID, unnamed3 *LPVOID) HRESULT {
|
|
ret1 := syscall6(iUnknown_QueryService, 4,
|
|
uintptr(unsafe.Pointer(unnamed0)),
|
|
uintptr(unsafe.Pointer(unnamed1)),
|
|
uintptr(unsafe.Pointer(unnamed2)),
|
|
uintptr(unsafe.Pointer(unnamed3)),
|
|
0,
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func IUnknown_Set(lppDest **IUnknown, lpUnknown *IUnknown) {
|
|
syscall3(iUnknown_Set, 2,
|
|
uintptr(unsafe.Pointer(lppDest)),
|
|
uintptr(unsafe.Pointer(lpUnknown)),
|
|
0)
|
|
}
|
|
|
|
func IUnknown_SetSite(obj *IUnknown, site *IUnknown) HRESULT {
|
|
ret1 := syscall3(iUnknown_SetSite, 2,
|
|
uintptr(unsafe.Pointer(obj)),
|
|
uintptr(unsafe.Pointer(site)),
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func IntlStrEqWorker(bCase bool, lpszStr string, lpszComp string, iLen int32) bool {
|
|
lpszStrStr := unicode16FromString(lpszStr)
|
|
lpszCompStr := unicode16FromString(lpszComp)
|
|
ret1 := syscall6(intlStrEqWorker, 4,
|
|
getUintptrFromBool(bCase),
|
|
uintptr(unsafe.Pointer(&lpszStrStr[0])),
|
|
uintptr(unsafe.Pointer(&lpszCompStr[0])),
|
|
uintptr(iLen),
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func IsCharSpace(wc WCHAR) bool {
|
|
ret1 := syscall3(isCharSpace, 1,
|
|
uintptr(wc),
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func IsInternetESCEnabled() bool {
|
|
ret1 := syscall3(isInternetESCEnabled, 0,
|
|
0,
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func IsOS(feature DWORD) bool {
|
|
ret1 := syscall3(isOS, 1,
|
|
uintptr(feature),
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func MLFreeLibrary(hModule HMODULE) bool {
|
|
ret1 := syscall3(mLFreeLibrary, 1,
|
|
uintptr(hModule),
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func MLLoadLibrary(new_mod string, inst_hwnd HMODULE, dwCrossCodePage DWORD) HMODULE {
|
|
new_modStr := unicode16FromString(new_mod)
|
|
ret1 := syscall3(mLLoadLibrary, 3,
|
|
uintptr(unsafe.Pointer(&new_modStr[0])),
|
|
uintptr(inst_hwnd),
|
|
uintptr(dwCrossCodePage))
|
|
return HMODULE(ret1)
|
|
}
|
|
|
|
func ParseURL(x string, y *PARSEDURL) HRESULT {
|
|
xStr := unicode16FromString(x)
|
|
ret1 := syscall3(parseURL, 2,
|
|
uintptr(unsafe.Pointer(&xStr[0])),
|
|
uintptr(unsafe.Pointer(y)),
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func PathAddBackslash(lpszPath LPWSTR) LPWSTR {
|
|
ret1 := syscall3(pathAddBackslash, 1,
|
|
uintptr(unsafe.Pointer(lpszPath)),
|
|
0,
|
|
0)
|
|
return (LPWSTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func PathAddExtension(lpszPath LPWSTR, lpszExtension string) bool {
|
|
lpszExtensionStr := unicode16FromString(lpszExtension)
|
|
ret1 := syscall3(pathAddExtension, 2,
|
|
uintptr(unsafe.Pointer(lpszPath)),
|
|
uintptr(unsafe.Pointer(&lpszExtensionStr[0])),
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathAppend(lpszPath LPWSTR, lpszAppend string) bool {
|
|
lpszAppendStr := unicode16FromString(lpszAppend)
|
|
ret1 := syscall3(pathAppend, 2,
|
|
uintptr(unsafe.Pointer(lpszPath)),
|
|
uintptr(unsafe.Pointer(&lpszAppendStr[0])),
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathBuildRoot(lpszPath LPWSTR, drive int32) LPWSTR {
|
|
ret1 := syscall3(pathBuildRoot, 2,
|
|
uintptr(unsafe.Pointer(lpszPath)),
|
|
uintptr(drive),
|
|
0)
|
|
return (LPWSTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func PathCanonicalize(lpszBuf LPWSTR, lpszPath string) bool {
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
ret1 := syscall3(pathCanonicalize, 2,
|
|
uintptr(unsafe.Pointer(lpszBuf)),
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])),
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathCombine(lpszDest LPWSTR, lpszDir string, lpszFile string) LPWSTR {
|
|
lpszDirStr := unicode16FromString(lpszDir)
|
|
lpszFileStr := unicode16FromString(lpszFile)
|
|
ret1 := syscall3(pathCombine, 3,
|
|
uintptr(unsafe.Pointer(lpszDest)),
|
|
uintptr(unsafe.Pointer(&lpszDirStr[0])),
|
|
uintptr(unsafe.Pointer(&lpszFileStr[0])))
|
|
return (LPWSTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func PathCommonPrefix(lpszFile1 string, lpszFile2 string, achPath LPWSTR) int32 {
|
|
lpszFile1Str := unicode16FromString(lpszFile1)
|
|
lpszFile2Str := unicode16FromString(lpszFile2)
|
|
ret1 := syscall3(pathCommonPrefix, 3,
|
|
uintptr(unsafe.Pointer(&lpszFile1Str[0])),
|
|
uintptr(unsafe.Pointer(&lpszFile2Str[0])),
|
|
uintptr(unsafe.Pointer(achPath)))
|
|
return int32(ret1)
|
|
}
|
|
|
|
func PathCompactPathEx(lpszDest LPWSTR, lpszPath string, cchMax UINT, dwFlags DWORD) bool {
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
ret1 := syscall6(pathCompactPathEx, 4,
|
|
uintptr(unsafe.Pointer(lpszDest)),
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])),
|
|
uintptr(cchMax),
|
|
uintptr(dwFlags),
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathCompactPath(hDC HDC, lpszPath LPWSTR, dx UINT) bool {
|
|
ret1 := syscall3(pathCompactPath, 3,
|
|
uintptr(hDC),
|
|
uintptr(unsafe.Pointer(lpszPath)),
|
|
uintptr(dx))
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathCreateFromUrlAlloc(pszUrl string, pszPath *LPWSTR, dwReserved DWORD) HRESULT {
|
|
pszUrlStr := unicode16FromString(pszUrl)
|
|
ret1 := syscall3(pathCreateFromUrlAlloc, 3,
|
|
uintptr(unsafe.Pointer(&pszUrlStr[0])),
|
|
uintptr(unsafe.Pointer(pszPath)),
|
|
uintptr(dwReserved))
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func PathCreateFromUrl(pszUrl string, pszPath LPWSTR, pcchPath *uint32, dwReserved DWORD) HRESULT {
|
|
pszUrlStr := unicode16FromString(pszUrl)
|
|
ret1 := syscall6(pathCreateFromUrl, 4,
|
|
uintptr(unsafe.Pointer(&pszUrlStr[0])),
|
|
uintptr(unsafe.Pointer(pszPath)),
|
|
uintptr(unsafe.Pointer(pcchPath)),
|
|
uintptr(dwReserved),
|
|
0,
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func PathFileExists(lpszPath string) bool {
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
ret1 := syscall3(pathFileExists, 1,
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])),
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathFindExtension(lpszPath string) LPWSTR {
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
ret1 := syscall3(pathFindExtension, 1,
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])),
|
|
0,
|
|
0)
|
|
return (LPWSTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func PathFindFileName(lpszPath string) LPWSTR {
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
ret1 := syscall3(pathFindFileName, 1,
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])),
|
|
0,
|
|
0)
|
|
return (LPWSTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func PathFindNextComponent(lpszPath string) LPWSTR {
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
ret1 := syscall3(pathFindNextComponent, 1,
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])),
|
|
0,
|
|
0)
|
|
return (LPWSTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func PathFindOnPath(lpszFile LPWSTR, lppszOtherDirs *LPCWSTR) bool {
|
|
ret1 := syscall3(pathFindOnPath, 2,
|
|
uintptr(unsafe.Pointer(lpszFile)),
|
|
uintptr(unsafe.Pointer(lppszOtherDirs)),
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathFindSuffixArray(lpszSuffix string, lppszArray *LPCWSTR, dwCount int32) string {
|
|
lpszSuffixStr := unicode16FromString(lpszSuffix)
|
|
ret1 := syscall3(pathFindSuffixArray, 3,
|
|
uintptr(unsafe.Pointer(&lpszSuffixStr[0])),
|
|
uintptr(unsafe.Pointer(lppszArray)),
|
|
uintptr(dwCount))
|
|
return stringFromUnicode16((*uint16)(unsafe.Pointer(ret1)))
|
|
}
|
|
|
|
func PathGetArgs(lpszPath string) LPWSTR {
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
ret1 := syscall3(pathGetArgs, 1,
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])),
|
|
0,
|
|
0)
|
|
return (LPWSTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func PathGetCharType(ch WCHAR) UINT {
|
|
ret1 := syscall3(pathGetCharType, 1,
|
|
uintptr(ch),
|
|
0,
|
|
0)
|
|
return UINT(ret1)
|
|
}
|
|
|
|
func PathGetDriveNumber(lpszPath string) int32 {
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
ret1 := syscall3(pathGetDriveNumber, 1,
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])),
|
|
0,
|
|
0)
|
|
return int32(ret1)
|
|
}
|
|
|
|
func PathIsContentType(lpszPath string, lpszContentType string) bool {
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
lpszContentTypeStr := unicode16FromString(lpszContentType)
|
|
ret1 := syscall3(pathIsContentType, 2,
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])),
|
|
uintptr(unsafe.Pointer(&lpszContentTypeStr[0])),
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathIsDirectoryEmpty(lpszPath string) bool {
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
ret1 := syscall3(pathIsDirectoryEmpty, 1,
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])),
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathIsDirectory(lpszPath string) bool {
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
ret1 := syscall3(pathIsDirectory, 1,
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])),
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathIsFileSpec(lpszPath string) bool {
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
ret1 := syscall3(pathIsFileSpec, 1,
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])),
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathIsLFNFileSpec(lpszPath string) bool {
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
ret1 := syscall3(pathIsLFNFileSpec, 1,
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])),
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathIsNetworkPath(lpszPath string) bool {
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
ret1 := syscall3(pathIsNetworkPath, 1,
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])),
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathIsPrefix(lpszPrefix string, lpszPath string) bool {
|
|
lpszPrefixStr := unicode16FromString(lpszPrefix)
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
ret1 := syscall3(pathIsPrefix, 2,
|
|
uintptr(unsafe.Pointer(&lpszPrefixStr[0])),
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])),
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathIsRelative(lpszPath string) bool {
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
ret1 := syscall3(pathIsRelative, 1,
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])),
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathIsRoot(lpszPath string) bool {
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
ret1 := syscall3(pathIsRoot, 1,
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])),
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathIsSameRoot(lpszPath1 string, lpszPath2 string) bool {
|
|
lpszPath1Str := unicode16FromString(lpszPath1)
|
|
lpszPath2Str := unicode16FromString(lpszPath2)
|
|
ret1 := syscall3(pathIsSameRoot, 2,
|
|
uintptr(unsafe.Pointer(&lpszPath1Str[0])),
|
|
uintptr(unsafe.Pointer(&lpszPath2Str[0])),
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathIsSystemFolder(lpszPath string, dwAttrib DWORD) bool {
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
ret1 := syscall3(pathIsSystemFolder, 2,
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])),
|
|
uintptr(dwAttrib),
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathIsUNCServerShare(lpszPath string) bool {
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
ret1 := syscall3(pathIsUNCServerShare, 1,
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])),
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathIsUNCServer(lpszPath string) bool {
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
ret1 := syscall3(pathIsUNCServer, 1,
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])),
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathIsUNC(lpszPath string) bool {
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
ret1 := syscall3(pathIsUNC, 1,
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])),
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathIsURL(lpstrPath string) bool {
|
|
lpstrPathStr := unicode16FromString(lpstrPath)
|
|
ret1 := syscall3(pathIsURL, 1,
|
|
uintptr(unsafe.Pointer(&lpstrPathStr[0])),
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathMakePretty(lpszPath LPWSTR) bool {
|
|
ret1 := syscall3(pathMakePretty, 1,
|
|
uintptr(unsafe.Pointer(lpszPath)),
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathMakeSystemFolder(lpszPath string) bool {
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
ret1 := syscall3(pathMakeSystemFolder, 1,
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])),
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathMatchSpec(lpszPath string, lpszMask string) bool {
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
lpszMaskStr := unicode16FromString(lpszMask)
|
|
ret1 := syscall3(pathMatchSpec, 2,
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])),
|
|
uintptr(unsafe.Pointer(&lpszMaskStr[0])),
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathParseIconLocation(lpszPath LPWSTR) int32 {
|
|
ret1 := syscall3(pathParseIconLocation, 1,
|
|
uintptr(unsafe.Pointer(lpszPath)),
|
|
0,
|
|
0)
|
|
return int32(ret1)
|
|
}
|
|
|
|
func PathQuoteSpaces(lpszPath LPWSTR) {
|
|
syscall3(pathQuoteSpaces, 1,
|
|
uintptr(unsafe.Pointer(lpszPath)),
|
|
0,
|
|
0)
|
|
}
|
|
|
|
func PathRelativePathTo(lpszPath LPWSTR, lpszFrom string, dwAttrFrom DWORD, lpszTo string, dwAttrTo DWORD) bool {
|
|
lpszFromStr := unicode16FromString(lpszFrom)
|
|
lpszToStr := unicode16FromString(lpszTo)
|
|
ret1 := syscall6(pathRelativePathTo, 5,
|
|
uintptr(unsafe.Pointer(lpszPath)),
|
|
uintptr(unsafe.Pointer(&lpszFromStr[0])),
|
|
uintptr(dwAttrFrom),
|
|
uintptr(unsafe.Pointer(&lpszToStr[0])),
|
|
uintptr(dwAttrTo),
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathRemoveArgs(lpszPath LPWSTR) {
|
|
syscall3(pathRemoveArgs, 1,
|
|
uintptr(unsafe.Pointer(lpszPath)),
|
|
0,
|
|
0)
|
|
}
|
|
|
|
func PathRemoveBackslash(lpszPath LPWSTR) LPWSTR {
|
|
ret1 := syscall3(pathRemoveBackslash, 1,
|
|
uintptr(unsafe.Pointer(lpszPath)),
|
|
0,
|
|
0)
|
|
return (LPWSTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func PathRemoveBlanks(lpszPath LPWSTR) {
|
|
syscall3(pathRemoveBlanks, 1,
|
|
uintptr(unsafe.Pointer(lpszPath)),
|
|
0,
|
|
0)
|
|
}
|
|
|
|
func PathRemoveExtension(lpszPath LPWSTR) {
|
|
syscall3(pathRemoveExtension, 1,
|
|
uintptr(unsafe.Pointer(lpszPath)),
|
|
0,
|
|
0)
|
|
}
|
|
|
|
func PathRemoveFileSpec(lpszPath LPWSTR) bool {
|
|
ret1 := syscall3(pathRemoveFileSpec, 1,
|
|
uintptr(unsafe.Pointer(lpszPath)),
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathRenameExtension(lpszPath LPWSTR, lpszExt string) bool {
|
|
lpszExtStr := unicode16FromString(lpszExt)
|
|
ret1 := syscall3(pathRenameExtension, 2,
|
|
uintptr(unsafe.Pointer(lpszPath)),
|
|
uintptr(unsafe.Pointer(&lpszExtStr[0])),
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathSearchAndQualify(lpszPath string, lpszBuf LPWSTR, cchBuf UINT) bool {
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
ret1 := syscall3(pathSearchAndQualify, 3,
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])),
|
|
uintptr(unsafe.Pointer(lpszBuf)),
|
|
uintptr(cchBuf))
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathSetDlgItemPath(hDlg HWND, id int32, lpszPath string) {
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
syscall3(pathSetDlgItemPath, 3,
|
|
uintptr(hDlg),
|
|
uintptr(id),
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])))
|
|
}
|
|
|
|
func PathSkipRoot(lpszPath string) LPWSTR {
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
ret1 := syscall3(pathSkipRoot, 1,
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])),
|
|
0,
|
|
0)
|
|
return (LPWSTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func PathStripPath(lpszPath LPWSTR) {
|
|
syscall3(pathStripPath, 1,
|
|
uintptr(unsafe.Pointer(lpszPath)),
|
|
0,
|
|
0)
|
|
}
|
|
|
|
func PathStripToRoot(lpszPath LPWSTR) bool {
|
|
ret1 := syscall3(pathStripToRoot, 1,
|
|
uintptr(unsafe.Pointer(lpszPath)),
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathUnExpandEnvStrings(path string, buffer LPWSTR, buf_len UINT) bool {
|
|
pathStr := unicode16FromString(path)
|
|
ret1 := syscall3(pathUnExpandEnvStrings, 3,
|
|
uintptr(unsafe.Pointer(&pathStr[0])),
|
|
uintptr(unsafe.Pointer(buffer)),
|
|
uintptr(buf_len))
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathUndecorate(lpszPath LPWSTR) {
|
|
syscall3(pathUndecorate, 1,
|
|
uintptr(unsafe.Pointer(lpszPath)),
|
|
0,
|
|
0)
|
|
}
|
|
|
|
func PathUnmakeSystemFolder(lpszPath string) bool {
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
ret1 := syscall3(pathUnmakeSystemFolder, 1,
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])),
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func PathUnquoteSpaces(lpszPath LPWSTR) {
|
|
syscall3(pathUnquoteSpaces, 1,
|
|
uintptr(unsafe.Pointer(lpszPath)),
|
|
0,
|
|
0)
|
|
}
|
|
|
|
func QISearch(base uintptr, table /*const*/ *QITAB, riid REFIID, ppv uintptr) HRESULT {
|
|
ret1 := syscall6(qISearch, 4,
|
|
base,
|
|
uintptr(unsafe.Pointer(table)),
|
|
uintptr(unsafe.Pointer(riid)),
|
|
ppv,
|
|
0,
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func SHAllocShared(lpvData LPVOID, dwSize DWORD, dwProcId DWORD) HANDLE {
|
|
ret1 := syscall3(sHAllocShared, 3,
|
|
uintptr(unsafe.Pointer(lpvData)),
|
|
uintptr(dwSize),
|
|
uintptr(dwProcId))
|
|
return HANDLE(ret1)
|
|
}
|
|
|
|
func SHAnsiToAnsi(lpszSrc /*const*/ LPCSTR, lpszDst LPSTR, iLen int32) DWORD {
|
|
ret1 := syscall3(sHAnsiToAnsi, 3,
|
|
uintptr(unsafe.Pointer(lpszSrc)),
|
|
uintptr(unsafe.Pointer(lpszDst)),
|
|
uintptr(iLen))
|
|
return DWORD(ret1)
|
|
}
|
|
|
|
func SHAnsiToUnicode(lpSrcStr /*const*/ LPCSTR, lpDstStr LPWSTR, iLen int32) DWORD {
|
|
ret1 := syscall3(sHAnsiToUnicode, 3,
|
|
uintptr(unsafe.Pointer(lpSrcStr)),
|
|
uintptr(unsafe.Pointer(lpDstStr)),
|
|
uintptr(iLen))
|
|
return DWORD(ret1)
|
|
}
|
|
|
|
func SHAutoComplete(hwndEdit HWND, dwFlags DWORD) HRESULT {
|
|
ret1 := syscall3(sHAutoComplete, 2,
|
|
uintptr(hwndEdit),
|
|
uintptr(dwFlags),
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func SHCopyKey(hKeySrc HKEY, lpszSrcSubKey string, hKeyDst HKEY, dwReserved DWORD) DWORD {
|
|
lpszSrcSubKeyStr := unicode16FromString(lpszSrcSubKey)
|
|
ret1 := syscall6(sHCopyKey, 4,
|
|
uintptr(hKeySrc),
|
|
uintptr(unsafe.Pointer(&lpszSrcSubKeyStr[0])),
|
|
uintptr(hKeyDst),
|
|
uintptr(dwReserved),
|
|
0,
|
|
0)
|
|
return DWORD(ret1)
|
|
}
|
|
|
|
func SHCreateShellPalette(hdc HDC) HPALETTE {
|
|
ret1 := syscall3(sHCreateShellPalette, 1,
|
|
uintptr(hdc),
|
|
0,
|
|
0)
|
|
return HPALETTE(ret1)
|
|
}
|
|
|
|
func SHCreateStreamOnFileEx(lpszPath string, dwMode DWORD, dwAttributes DWORD, bCreate bool, lpTemplate *IStream, lppStream **IStream) HRESULT {
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
ret1 := syscall6(sHCreateStreamOnFileEx, 6,
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])),
|
|
uintptr(dwMode),
|
|
uintptr(dwAttributes),
|
|
getUintptrFromBool(bCreate),
|
|
uintptr(unsafe.Pointer(lpTemplate)),
|
|
uintptr(unsafe.Pointer(lppStream)))
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func SHCreateStreamOnFile(lpszPath string, dwMode DWORD, lppStream **IStream) HRESULT {
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
ret1 := syscall3(sHCreateStreamOnFile, 3,
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])),
|
|
uintptr(dwMode),
|
|
uintptr(unsafe.Pointer(lppStream)))
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func SHCreateStreamWrapper(lpbData *byte, dwDataLen DWORD, dwReserved DWORD, lppStream **IStream) HRESULT {
|
|
ret1 := syscall6(sHCreateStreamWrapper, 4,
|
|
uintptr(unsafe.Pointer(lpbData)),
|
|
uintptr(dwDataLen),
|
|
uintptr(dwReserved),
|
|
uintptr(unsafe.Pointer(lppStream)),
|
|
0,
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func SHCreateThread(pfnThreadProc THREAD_START_ROUTINE, pData uintptr, dwFlags DWORD, pfnCallback THREAD_START_ROUTINE) bool {
|
|
pfnThreadProcCallback := syscall.NewCallback(func(lpThreadParameterRawArg LPVOID) uintptr {
|
|
ret := pfnThreadProc(lpThreadParameterRawArg)
|
|
return uintptr(ret)
|
|
})
|
|
pfnCallbackCallback := syscall.NewCallback(func(lpThreadParameterRawArg LPVOID) uintptr {
|
|
ret := pfnCallback(lpThreadParameterRawArg)
|
|
return uintptr(ret)
|
|
})
|
|
ret1 := syscall6(sHCreateThread, 4,
|
|
pfnThreadProcCallback,
|
|
pData,
|
|
uintptr(dwFlags),
|
|
pfnCallbackCallback,
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func SHCreateThreadRef(lprefcount *LONG, lppUnknown **IUnknown) HRESULT {
|
|
ret1 := syscall3(sHCreateThreadRef, 2,
|
|
uintptr(unsafe.Pointer(lprefcount)),
|
|
uintptr(unsafe.Pointer(lppUnknown)),
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func SHDeleteEmptyKey(hKey HKEY, lpszSubKey string) DWORD {
|
|
lpszSubKeyStr := unicode16FromString(lpszSubKey)
|
|
ret1 := syscall3(sHDeleteEmptyKey, 2,
|
|
uintptr(hKey),
|
|
uintptr(unsafe.Pointer(&lpszSubKeyStr[0])),
|
|
0)
|
|
return DWORD(ret1)
|
|
}
|
|
|
|
func SHDeleteKey(hKey HKEY, lpszSubKey string) DWORD {
|
|
lpszSubKeyStr := unicode16FromString(lpszSubKey)
|
|
ret1 := syscall3(sHDeleteKey, 2,
|
|
uintptr(hKey),
|
|
uintptr(unsafe.Pointer(&lpszSubKeyStr[0])),
|
|
0)
|
|
return DWORD(ret1)
|
|
}
|
|
|
|
func SHDeleteOrphanKey(hKey HKEY, lpszSubKey string) DWORD {
|
|
lpszSubKeyStr := unicode16FromString(lpszSubKey)
|
|
ret1 := syscall3(sHDeleteOrphanKey, 2,
|
|
uintptr(hKey),
|
|
uintptr(unsafe.Pointer(&lpszSubKeyStr[0])),
|
|
0)
|
|
return DWORD(ret1)
|
|
}
|
|
|
|
func SHDeleteValue(hKey HKEY, lpszSubKey string, lpszValue string) DWORD {
|
|
lpszSubKeyStr := unicode16FromString(lpszSubKey)
|
|
lpszValueStr := unicode16FromString(lpszValue)
|
|
ret1 := syscall3(sHDeleteValue, 3,
|
|
uintptr(hKey),
|
|
uintptr(unsafe.Pointer(&lpszSubKeyStr[0])),
|
|
uintptr(unsafe.Pointer(&lpszValueStr[0])))
|
|
return DWORD(ret1)
|
|
}
|
|
|
|
func SHEnumKeyEx(hKey HKEY, dwIndex DWORD, lpszSubKey LPWSTR, pwLen *uint32) LONG {
|
|
ret1 := syscall6(sHEnumKeyEx, 4,
|
|
uintptr(hKey),
|
|
uintptr(dwIndex),
|
|
uintptr(unsafe.Pointer(lpszSubKey)),
|
|
uintptr(unsafe.Pointer(pwLen)),
|
|
0,
|
|
0)
|
|
return LONG(ret1)
|
|
}
|
|
|
|
func SHEnumValue(hKey HKEY, dwIndex DWORD, lpszValue LPWSTR, pwLen *uint32, pwType *uint32, pvData LPVOID, pcbData *uint32) LONG {
|
|
ret1 := syscall9(sHEnumValue, 7,
|
|
uintptr(hKey),
|
|
uintptr(dwIndex),
|
|
uintptr(unsafe.Pointer(lpszValue)),
|
|
uintptr(unsafe.Pointer(pwLen)),
|
|
uintptr(unsafe.Pointer(pwType)),
|
|
uintptr(unsafe.Pointer(pvData)),
|
|
uintptr(unsafe.Pointer(pcbData)),
|
|
0,
|
|
0)
|
|
return LONG(ret1)
|
|
}
|
|
|
|
func SHFormatDateTime(fileTime /*const*/ *FILETIME, flags *uint32, buf LPWSTR, size UINT) INT {
|
|
ret1 := syscall6(sHFormatDateTime, 4,
|
|
uintptr(unsafe.Pointer(fileTime)),
|
|
uintptr(unsafe.Pointer(flags)),
|
|
uintptr(unsafe.Pointer(buf)),
|
|
uintptr(size),
|
|
0,
|
|
0)
|
|
return INT(ret1)
|
|
}
|
|
|
|
func SHFreeShared(hShared HANDLE, dwProcId DWORD) bool {
|
|
ret1 := syscall3(sHFreeShared, 2,
|
|
uintptr(hShared),
|
|
uintptr(dwProcId),
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func SHGetInverseCMAP(dest *uint32, dwSize DWORD) HRESULT {
|
|
ret1 := syscall3(sHGetInverseCMAP, 2,
|
|
uintptr(unsafe.Pointer(dest)),
|
|
uintptr(dwSize),
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func SHGetThreadRef(lppUnknown **IUnknown) HRESULT {
|
|
ret1 := syscall3(sHGetThreadRef, 1,
|
|
uintptr(unsafe.Pointer(lppUnknown)),
|
|
0,
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func SHGetValue(hKey HKEY, lpszSubKey string, lpszValue string, pwType *uint32, pvData LPVOID, pcbData *uint32) DWORD {
|
|
lpszSubKeyStr := unicode16FromString(lpszSubKey)
|
|
lpszValueStr := unicode16FromString(lpszValue)
|
|
ret1 := syscall6(sHGetValue, 6,
|
|
uintptr(hKey),
|
|
uintptr(unsafe.Pointer(&lpszSubKeyStr[0])),
|
|
uintptr(unsafe.Pointer(&lpszValueStr[0])),
|
|
uintptr(unsafe.Pointer(pwType)),
|
|
uintptr(unsafe.Pointer(pvData)),
|
|
uintptr(unsafe.Pointer(pcbData)))
|
|
return DWORD(ret1)
|
|
}
|
|
|
|
func SHGetViewStatePropertyBag(pidl /*const*/ LPCITEMIDLIST, bag_name LPWSTR, flags DWORD, riid REFIID, ppv uintptr) HRESULT {
|
|
ret1 := syscall6(sHGetViewStatePropertyBag, 5,
|
|
uintptr(unsafe.Pointer(pidl)),
|
|
uintptr(unsafe.Pointer(bag_name)),
|
|
uintptr(flags),
|
|
uintptr(unsafe.Pointer(riid)),
|
|
ppv,
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func SHIsChildOrSelf(hParent HWND, hChild HWND) bool {
|
|
ret1 := syscall3(sHIsChildOrSelf, 2,
|
|
uintptr(hParent),
|
|
uintptr(hChild),
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func SHIsLowMemoryMachine(x DWORD) bool {
|
|
ret1 := syscall3(sHIsLowMemoryMachine, 1,
|
|
uintptr(x),
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func SHLoadIndirectString(src string, dst LPWSTR, dst_len UINT, reserved uintptr) HRESULT {
|
|
srcStr := unicode16FromString(src)
|
|
ret1 := syscall6(sHLoadIndirectString, 4,
|
|
uintptr(unsafe.Pointer(&srcStr[0])),
|
|
uintptr(unsafe.Pointer(dst)),
|
|
uintptr(dst_len),
|
|
reserved,
|
|
0,
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func SHLockShared(hShared HANDLE, dwProcId DWORD) LPVOID {
|
|
ret1 := syscall3(sHLockShared, 2,
|
|
uintptr(hShared),
|
|
uintptr(dwProcId),
|
|
0)
|
|
return (LPVOID)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func SHMessageBoxCheck(unnamed0 HWND, unnamed1 string, unnamed2 string, unnamed3 DWORD, unnamed4 INT_PTR, unnamed5 string) INT_PTR {
|
|
unnamed1Str := unicode16FromString(unnamed1)
|
|
unnamed2Str := unicode16FromString(unnamed2)
|
|
unnamed5Str := unicode16FromString(unnamed5)
|
|
ret1 := syscall6(sHMessageBoxCheck, 6,
|
|
uintptr(unnamed0),
|
|
uintptr(unsafe.Pointer(&unnamed1Str[0])),
|
|
uintptr(unsafe.Pointer(&unnamed2Str[0])),
|
|
uintptr(unnamed3),
|
|
uintptr(unsafe.Pointer(unnamed4)),
|
|
uintptr(unsafe.Pointer(&unnamed5Str[0])))
|
|
return (INT_PTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func SHQueryInfoKey(hKey HKEY, pwSubKeys *uint32, pwSubKeyMax *uint32, pwValues *uint32, pwValueMax *uint32) LONG {
|
|
ret1 := syscall6(sHQueryInfoKey, 5,
|
|
uintptr(hKey),
|
|
uintptr(unsafe.Pointer(pwSubKeys)),
|
|
uintptr(unsafe.Pointer(pwSubKeyMax)),
|
|
uintptr(unsafe.Pointer(pwValues)),
|
|
uintptr(unsafe.Pointer(pwValueMax)),
|
|
0)
|
|
return LONG(ret1)
|
|
}
|
|
|
|
func SHQueryValueEx(hKey HKEY, lpszValue string, lpReserved *uint32, pwType *uint32, pvData LPVOID, pcbData *uint32) DWORD {
|
|
lpszValueStr := unicode16FromString(lpszValue)
|
|
ret1 := syscall6(sHQueryValueEx, 6,
|
|
uintptr(hKey),
|
|
uintptr(unsafe.Pointer(&lpszValueStr[0])),
|
|
uintptr(unsafe.Pointer(lpReserved)),
|
|
uintptr(unsafe.Pointer(pwType)),
|
|
uintptr(unsafe.Pointer(pvData)),
|
|
uintptr(unsafe.Pointer(pcbData)))
|
|
return DWORD(ret1)
|
|
}
|
|
|
|
func SHRegCloseUSKey(hUSKey HUSKEY) LONG {
|
|
ret1 := syscall3(sHRegCloseUSKey, 1,
|
|
uintptr(hUSKey),
|
|
0,
|
|
0)
|
|
return LONG(ret1)
|
|
}
|
|
|
|
func SHRegCreateUSKey(path string, samDesired REGSAM, relative_key HUSKEY, new_uskey PHUSKEY, flags DWORD) LONG {
|
|
pathStr := unicode16FromString(path)
|
|
ret1 := syscall6(sHRegCreateUSKey, 5,
|
|
uintptr(unsafe.Pointer(&pathStr[0])),
|
|
uintptr(samDesired),
|
|
uintptr(relative_key),
|
|
uintptr(unsafe.Pointer(new_uskey)),
|
|
uintptr(flags),
|
|
0)
|
|
return LONG(ret1)
|
|
}
|
|
|
|
func SHRegDeleteEmptyUSKey(hUSKey HUSKEY, pszValue string, delRegFlags SHREGDEL_FLAGS) LONG {
|
|
pszValueStr := unicode16FromString(pszValue)
|
|
ret1 := syscall3(sHRegDeleteEmptyUSKey, 3,
|
|
uintptr(hUSKey),
|
|
uintptr(unsafe.Pointer(&pszValueStr[0])),
|
|
uintptr(delRegFlags))
|
|
return LONG(ret1)
|
|
}
|
|
|
|
func SHRegDeleteUSValue(hUSKey HUSKEY, pszValue string, delRegFlags SHREGDEL_FLAGS) LONG {
|
|
pszValueStr := unicode16FromString(pszValue)
|
|
ret1 := syscall3(sHRegDeleteUSValue, 3,
|
|
uintptr(hUSKey),
|
|
uintptr(unsafe.Pointer(&pszValueStr[0])),
|
|
uintptr(delRegFlags))
|
|
return LONG(ret1)
|
|
}
|
|
|
|
func SHRegDuplicateHKey(hKey HKEY) HKEY {
|
|
ret1 := syscall3(sHRegDuplicateHKey, 1,
|
|
uintptr(hKey),
|
|
0,
|
|
0)
|
|
return HKEY(ret1)
|
|
}
|
|
|
|
func SHRegEnumUSKey(hUSKey HUSKEY, dwIndex DWORD, pszName LPWSTR, pcchValueNameLen *uint32, enumRegFlags SHREGENUM_FLAGS) LONG {
|
|
ret1 := syscall6(sHRegEnumUSKey, 5,
|
|
uintptr(hUSKey),
|
|
uintptr(dwIndex),
|
|
uintptr(unsafe.Pointer(pszName)),
|
|
uintptr(unsafe.Pointer(pcchValueNameLen)),
|
|
uintptr(enumRegFlags),
|
|
0)
|
|
return LONG(ret1)
|
|
}
|
|
|
|
func SHRegEnumUSValue(hUSKey HUSKEY, dwIndex DWORD, pszValueName LPWSTR, pcchValueNameLen *uint32, pdwType *uint32, pvData LPVOID, pcbData *uint32, enumRegFlags SHREGENUM_FLAGS) LONG {
|
|
ret1 := syscall9(sHRegEnumUSValue, 8,
|
|
uintptr(hUSKey),
|
|
uintptr(dwIndex),
|
|
uintptr(unsafe.Pointer(pszValueName)),
|
|
uintptr(unsafe.Pointer(pcchValueNameLen)),
|
|
uintptr(unsafe.Pointer(pdwType)),
|
|
uintptr(unsafe.Pointer(pvData)),
|
|
uintptr(unsafe.Pointer(pcbData)),
|
|
uintptr(enumRegFlags),
|
|
0)
|
|
return LONG(ret1)
|
|
}
|
|
|
|
func SHRegGetBoolUSValue(pszSubKey string, pszValue string, fIgnoreHKCU bool, fDefault bool) bool {
|
|
pszSubKeyStr := unicode16FromString(pszSubKey)
|
|
pszValueStr := unicode16FromString(pszValue)
|
|
ret1 := syscall6(sHRegGetBoolUSValue, 4,
|
|
uintptr(unsafe.Pointer(&pszSubKeyStr[0])),
|
|
uintptr(unsafe.Pointer(&pszValueStr[0])),
|
|
getUintptrFromBool(fIgnoreHKCU),
|
|
getUintptrFromBool(fDefault),
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func SHRegGetIntW(hKey HKEY, lpszValue string, iDefault int32) int32 {
|
|
lpszValueStr := unicode16FromString(lpszValue)
|
|
ret1 := syscall3(sHRegGetIntW, 3,
|
|
uintptr(hKey),
|
|
uintptr(unsafe.Pointer(&lpszValueStr[0])),
|
|
uintptr(iDefault))
|
|
return int32(ret1)
|
|
}
|
|
|
|
func SHRegGetPath(hKey HKEY, lpszSubKey string, lpszValue string, lpszPath LPWSTR, dwFlags DWORD) DWORD {
|
|
lpszSubKeyStr := unicode16FromString(lpszSubKey)
|
|
lpszValueStr := unicode16FromString(lpszValue)
|
|
ret1 := syscall6(sHRegGetPath, 5,
|
|
uintptr(hKey),
|
|
uintptr(unsafe.Pointer(&lpszSubKeyStr[0])),
|
|
uintptr(unsafe.Pointer(&lpszValueStr[0])),
|
|
uintptr(unsafe.Pointer(lpszPath)),
|
|
uintptr(dwFlags),
|
|
0)
|
|
return DWORD(ret1)
|
|
}
|
|
|
|
func SHRegGetUSValue(pSubKey string, pValue string, pwType *uint32, pvData LPVOID, pcbData *uint32, flagIgnoreHKCU bool, pDefaultData LPVOID, wDefaultDataSize DWORD) LONG {
|
|
pSubKeyStr := unicode16FromString(pSubKey)
|
|
pValueStr := unicode16FromString(pValue)
|
|
ret1 := syscall9(sHRegGetUSValue, 8,
|
|
uintptr(unsafe.Pointer(&pSubKeyStr[0])),
|
|
uintptr(unsafe.Pointer(&pValueStr[0])),
|
|
uintptr(unsafe.Pointer(pwType)),
|
|
uintptr(unsafe.Pointer(pvData)),
|
|
uintptr(unsafe.Pointer(pcbData)),
|
|
getUintptrFromBool(flagIgnoreHKCU),
|
|
uintptr(unsafe.Pointer(pDefaultData)),
|
|
uintptr(wDefaultDataSize),
|
|
0)
|
|
return LONG(ret1)
|
|
}
|
|
|
|
func SHRegOpenUSKey(path string, accessType REGSAM, hRelativeUSKey HUSKEY, phNewUSKey PHUSKEY, fIgnoreHKCU bool) LONG {
|
|
pathStr := unicode16FromString(path)
|
|
ret1 := syscall6(sHRegOpenUSKey, 5,
|
|
uintptr(unsafe.Pointer(&pathStr[0])),
|
|
uintptr(accessType),
|
|
uintptr(hRelativeUSKey),
|
|
uintptr(unsafe.Pointer(phNewUSKey)),
|
|
getUintptrFromBool(fIgnoreHKCU),
|
|
0)
|
|
return LONG(ret1)
|
|
}
|
|
|
|
func SHRegQueryInfoUSKey(hUSKey HUSKEY, pcSubKeys *uint32, pcchMaxSubKeyLen *uint32, pcValues *uint32, pcchMaxValueNameLen *uint32, enumRegFlags SHREGENUM_FLAGS) LONG {
|
|
ret1 := syscall6(sHRegQueryInfoUSKey, 6,
|
|
uintptr(hUSKey),
|
|
uintptr(unsafe.Pointer(pcSubKeys)),
|
|
uintptr(unsafe.Pointer(pcchMaxSubKeyLen)),
|
|
uintptr(unsafe.Pointer(pcValues)),
|
|
uintptr(unsafe.Pointer(pcchMaxValueNameLen)),
|
|
uintptr(enumRegFlags))
|
|
return LONG(ret1)
|
|
}
|
|
|
|
func SHRegQueryUSValue(hUSKey HUSKEY, pszValue string, pdwType *uint32, pvData LPVOID, pcbData *uint32, fIgnoreHKCU bool, pvDefaultData LPVOID, dwDefaultDataSize DWORD) LONG {
|
|
pszValueStr := unicode16FromString(pszValue)
|
|
ret1 := syscall9(sHRegQueryUSValue, 8,
|
|
uintptr(hUSKey),
|
|
uintptr(unsafe.Pointer(&pszValueStr[0])),
|
|
uintptr(unsafe.Pointer(pdwType)),
|
|
uintptr(unsafe.Pointer(pvData)),
|
|
uintptr(unsafe.Pointer(pcbData)),
|
|
getUintptrFromBool(fIgnoreHKCU),
|
|
uintptr(unsafe.Pointer(pvDefaultData)),
|
|
uintptr(dwDefaultDataSize),
|
|
0)
|
|
return LONG(ret1)
|
|
}
|
|
|
|
func SHRegSetPath(hKey HKEY, lpszSubKey string, lpszValue string, lpszPath string, dwFlags DWORD) DWORD {
|
|
lpszSubKeyStr := unicode16FromString(lpszSubKey)
|
|
lpszValueStr := unicode16FromString(lpszValue)
|
|
lpszPathStr := unicode16FromString(lpszPath)
|
|
ret1 := syscall6(sHRegSetPath, 5,
|
|
uintptr(hKey),
|
|
uintptr(unsafe.Pointer(&lpszSubKeyStr[0])),
|
|
uintptr(unsafe.Pointer(&lpszValueStr[0])),
|
|
uintptr(unsafe.Pointer(&lpszPathStr[0])),
|
|
uintptr(dwFlags),
|
|
0)
|
|
return DWORD(ret1)
|
|
}
|
|
|
|
func SHRegSetUSValue(pszSubKey string, pszValue string, dwType DWORD, pvData LPVOID, cbData DWORD, dwFlags DWORD) LONG {
|
|
pszSubKeyStr := unicode16FromString(pszSubKey)
|
|
pszValueStr := unicode16FromString(pszValue)
|
|
ret1 := syscall6(sHRegSetUSValue, 6,
|
|
uintptr(unsafe.Pointer(&pszSubKeyStr[0])),
|
|
uintptr(unsafe.Pointer(&pszValueStr[0])),
|
|
uintptr(dwType),
|
|
uintptr(unsafe.Pointer(pvData)),
|
|
uintptr(cbData),
|
|
uintptr(dwFlags))
|
|
return LONG(ret1)
|
|
}
|
|
|
|
func SHRegWriteUSValue(hUSKey HUSKEY, pszValue string, dwType DWORD, pvData LPVOID, cbData DWORD, dwFlags DWORD) LONG {
|
|
pszValueStr := unicode16FromString(pszValue)
|
|
ret1 := syscall6(sHRegWriteUSValue, 6,
|
|
uintptr(hUSKey),
|
|
uintptr(unsafe.Pointer(&pszValueStr[0])),
|
|
uintptr(dwType),
|
|
uintptr(unsafe.Pointer(pvData)),
|
|
uintptr(cbData),
|
|
uintptr(dwFlags))
|
|
return LONG(ret1)
|
|
}
|
|
|
|
func SHRegisterValidateTemplate(filename string, unknown bool) HRESULT {
|
|
filenameStr := unicode16FromString(filename)
|
|
ret1 := syscall3(sHRegisterValidateTemplate, 2,
|
|
uintptr(unsafe.Pointer(&filenameStr[0])),
|
|
getUintptrFromBool(unknown),
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func SHReleaseThreadRef() HRESULT {
|
|
ret1 := syscall3(sHReleaseThreadRef, 0,
|
|
0,
|
|
0,
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func SHSendMessageBroadcast(uMsg UINT, wParam WPARAM, lParam LPARAM) DWORD {
|
|
ret1 := syscall3(sHSendMessageBroadcast, 3,
|
|
uintptr(uMsg),
|
|
uintptr(wParam),
|
|
uintptr(lParam))
|
|
return DWORD(ret1)
|
|
}
|
|
|
|
func SHSetThreadRef(lpUnknown *IUnknown) HRESULT {
|
|
ret1 := syscall3(sHSetThreadRef, 1,
|
|
uintptr(unsafe.Pointer(lpUnknown)),
|
|
0,
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func SHSetValue(hKey HKEY, lpszSubKey string, lpszValue string, dwType DWORD, pvData /*const*/ uintptr, cbData DWORD) DWORD {
|
|
lpszSubKeyStr := unicode16FromString(lpszSubKey)
|
|
lpszValueStr := unicode16FromString(lpszValue)
|
|
ret1 := syscall6(sHSetValue, 6,
|
|
uintptr(hKey),
|
|
uintptr(unsafe.Pointer(&lpszSubKeyStr[0])),
|
|
uintptr(unsafe.Pointer(&lpszValueStr[0])),
|
|
uintptr(dwType),
|
|
pvData,
|
|
uintptr(cbData))
|
|
return DWORD(ret1)
|
|
}
|
|
|
|
func SHSkipJunction(pbc *IBindCtx, pclsid /*const*/ *CLSID) bool {
|
|
ret1 := syscall3(sHSkipJunction, 2,
|
|
uintptr(unsafe.Pointer(pbc)),
|
|
uintptr(unsafe.Pointer(pclsid)),
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func SHStrDup(src string, dest *LPWSTR) HRESULT {
|
|
srcStr := unicode16FromString(src)
|
|
ret1 := syscall3(sHStrDup, 2,
|
|
uintptr(unsafe.Pointer(&srcStr[0])),
|
|
uintptr(unsafe.Pointer(dest)),
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func SHStripMneumonic(lpszStr string) WCHAR {
|
|
lpszStrStr := unicode16FromString(lpszStr)
|
|
ret1 := syscall3(sHStripMneumonic, 1,
|
|
uintptr(unsafe.Pointer(&lpszStrStr[0])),
|
|
0,
|
|
0)
|
|
return WCHAR(ret1)
|
|
}
|
|
|
|
func SHUnicodeToAnsi(lpSrcStr string, lpDstStr LPSTR, iLen INT) INT {
|
|
lpSrcStrStr := unicode16FromString(lpSrcStr)
|
|
ret1 := syscall3(sHUnicodeToAnsi, 3,
|
|
uintptr(unsafe.Pointer(&lpSrcStrStr[0])),
|
|
uintptr(unsafe.Pointer(lpDstStr)),
|
|
uintptr(iLen))
|
|
return INT(ret1)
|
|
}
|
|
|
|
func SHUnicodeToUnicode(lpszSrc string, lpszDst LPWSTR, iLen int32) DWORD {
|
|
lpszSrcStr := unicode16FromString(lpszSrc)
|
|
ret1 := syscall3(sHUnicodeToUnicode, 3,
|
|
uintptr(unsafe.Pointer(&lpszSrcStr[0])),
|
|
uintptr(unsafe.Pointer(lpszDst)),
|
|
uintptr(iLen))
|
|
return DWORD(ret1)
|
|
}
|
|
|
|
func SHUnlockShared(lpView LPVOID) bool {
|
|
ret1 := syscall3(sHUnlockShared, 1,
|
|
uintptr(unsafe.Pointer(lpView)),
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func StrCSpnI(lpszStr string, lpszMatch string) int32 {
|
|
lpszStrStr := unicode16FromString(lpszStr)
|
|
lpszMatchStr := unicode16FromString(lpszMatch)
|
|
ret1 := syscall3(strCSpnI, 2,
|
|
uintptr(unsafe.Pointer(&lpszStrStr[0])),
|
|
uintptr(unsafe.Pointer(&lpszMatchStr[0])),
|
|
0)
|
|
return int32(ret1)
|
|
}
|
|
|
|
func StrCSpn(lpszStr string, lpszMatch string) int32 {
|
|
lpszStrStr := unicode16FromString(lpszStr)
|
|
lpszMatchStr := unicode16FromString(lpszMatch)
|
|
ret1 := syscall3(strCSpn, 2,
|
|
uintptr(unsafe.Pointer(&lpszStrStr[0])),
|
|
uintptr(unsafe.Pointer(&lpszMatchStr[0])),
|
|
0)
|
|
return int32(ret1)
|
|
}
|
|
|
|
func StrCatBuff(lpszStr LPWSTR, lpszCat string, cchMax INT) LPWSTR {
|
|
lpszCatStr := unicode16FromString(lpszCat)
|
|
ret1 := syscall3(strCatBuff, 3,
|
|
uintptr(unsafe.Pointer(lpszStr)),
|
|
uintptr(unsafe.Pointer(&lpszCatStr[0])),
|
|
uintptr(cchMax))
|
|
return (LPWSTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func StrCatChainW(lpszStr LPWSTR, cchMax DWORD, ichAt DWORD, lpszCat string) DWORD {
|
|
lpszCatStr := unicode16FromString(lpszCat)
|
|
ret1 := syscall6(strCatChainW, 4,
|
|
uintptr(unsafe.Pointer(lpszStr)),
|
|
uintptr(cchMax),
|
|
uintptr(ichAt),
|
|
uintptr(unsafe.Pointer(&lpszCatStr[0])),
|
|
0,
|
|
0)
|
|
return DWORD(ret1)
|
|
}
|
|
|
|
func StrCatW(lpszStr LPWSTR, lpszSrc string) LPWSTR {
|
|
lpszSrcStr := unicode16FromString(lpszSrc)
|
|
ret1 := syscall3(strCatW, 2,
|
|
uintptr(unsafe.Pointer(lpszStr)),
|
|
uintptr(unsafe.Pointer(&lpszSrcStr[0])),
|
|
0)
|
|
return (LPWSTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func StrChrI(lpszStr string, ch WCHAR) LPWSTR {
|
|
lpszStrStr := unicode16FromString(lpszStr)
|
|
ret1 := syscall3(strChrI, 2,
|
|
uintptr(unsafe.Pointer(&lpszStrStr[0])),
|
|
uintptr(ch),
|
|
0)
|
|
return (LPWSTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func StrChrNW(lpszStr string, ch WCHAR, cchMax UINT) LPWSTR {
|
|
lpszStrStr := unicode16FromString(lpszStr)
|
|
ret1 := syscall3(strChrNW, 3,
|
|
uintptr(unsafe.Pointer(&lpszStrStr[0])),
|
|
uintptr(ch),
|
|
uintptr(cchMax))
|
|
return (LPWSTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func StrChr(lpszStr string, ch WCHAR) LPWSTR {
|
|
lpszStrStr := unicode16FromString(lpszStr)
|
|
ret1 := syscall3(strChr, 2,
|
|
uintptr(unsafe.Pointer(&lpszStrStr[0])),
|
|
uintptr(ch),
|
|
0)
|
|
return (LPWSTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func StrCmpC(lpszSrc string, lpszCmp string) DWORD {
|
|
lpszSrcStr := unicode16FromString(lpszSrc)
|
|
lpszCmpStr := unicode16FromString(lpszCmp)
|
|
ret1 := syscall3(strCmpC, 2,
|
|
uintptr(unsafe.Pointer(&lpszSrcStr[0])),
|
|
uintptr(unsafe.Pointer(&lpszCmpStr[0])),
|
|
0)
|
|
return DWORD(ret1)
|
|
}
|
|
|
|
func StrCmpIC(lpszSrc string, lpszCmp string) DWORD {
|
|
lpszSrcStr := unicode16FromString(lpszSrc)
|
|
lpszCmpStr := unicode16FromString(lpszCmp)
|
|
ret1 := syscall3(strCmpIC, 2,
|
|
uintptr(unsafe.Pointer(&lpszSrcStr[0])),
|
|
uintptr(unsafe.Pointer(&lpszCmpStr[0])),
|
|
0)
|
|
return DWORD(ret1)
|
|
}
|
|
|
|
func StrCmpIW(lpszStr string, lpszComp string) int32 {
|
|
lpszStrStr := unicode16FromString(lpszStr)
|
|
lpszCompStr := unicode16FromString(lpszComp)
|
|
ret1 := syscall3(strCmpIW, 2,
|
|
uintptr(unsafe.Pointer(&lpszStrStr[0])),
|
|
uintptr(unsafe.Pointer(&lpszCompStr[0])),
|
|
0)
|
|
return int32(ret1)
|
|
}
|
|
|
|
func StrCmpLogicalW(lpszStr string, lpszComp string) INT {
|
|
lpszStrStr := unicode16FromString(lpszStr)
|
|
lpszCompStr := unicode16FromString(lpszComp)
|
|
ret1 := syscall3(strCmpLogicalW, 2,
|
|
uintptr(unsafe.Pointer(&lpszStrStr[0])),
|
|
uintptr(unsafe.Pointer(&lpszCompStr[0])),
|
|
0)
|
|
return INT(ret1)
|
|
}
|
|
|
|
func StrCmpNC(lpszSrc string, lpszCmp string, aLen INT) DWORD {
|
|
lpszSrcStr := unicode16FromString(lpszSrc)
|
|
lpszCmpStr := unicode16FromString(lpszCmp)
|
|
ret1 := syscall3(strCmpNC, 3,
|
|
uintptr(unsafe.Pointer(&lpszSrcStr[0])),
|
|
uintptr(unsafe.Pointer(&lpszCmpStr[0])),
|
|
uintptr(aLen))
|
|
return DWORD(ret1)
|
|
}
|
|
|
|
func StrCmpNIC(lpszSrc string, lpszCmp string, aLen DWORD) DWORD {
|
|
lpszSrcStr := unicode16FromString(lpszSrc)
|
|
lpszCmpStr := unicode16FromString(lpszCmp)
|
|
ret1 := syscall3(strCmpNIC, 3,
|
|
uintptr(unsafe.Pointer(&lpszSrcStr[0])),
|
|
uintptr(unsafe.Pointer(&lpszCmpStr[0])),
|
|
uintptr(aLen))
|
|
return DWORD(ret1)
|
|
}
|
|
|
|
func StrCmpNI(lpszStr string, lpszComp string, iLen INT) INT {
|
|
lpszStrStr := unicode16FromString(lpszStr)
|
|
lpszCompStr := unicode16FromString(lpszComp)
|
|
ret1 := syscall3(strCmpNI, 3,
|
|
uintptr(unsafe.Pointer(&lpszStrStr[0])),
|
|
uintptr(unsafe.Pointer(&lpszCompStr[0])),
|
|
uintptr(iLen))
|
|
return INT(ret1)
|
|
}
|
|
|
|
func StrCmpN(lpszStr string, lpszComp string, iLen INT) INT {
|
|
lpszStrStr := unicode16FromString(lpszStr)
|
|
lpszCompStr := unicode16FromString(lpszComp)
|
|
ret1 := syscall3(strCmpN, 3,
|
|
uintptr(unsafe.Pointer(&lpszStrStr[0])),
|
|
uintptr(unsafe.Pointer(&lpszCompStr[0])),
|
|
uintptr(iLen))
|
|
return INT(ret1)
|
|
}
|
|
|
|
func StrCmpW(lpszStr string, lpszComp string) int32 {
|
|
lpszStrStr := unicode16FromString(lpszStr)
|
|
lpszCompStr := unicode16FromString(lpszComp)
|
|
ret1 := syscall3(strCmpW, 2,
|
|
uintptr(unsafe.Pointer(&lpszStrStr[0])),
|
|
uintptr(unsafe.Pointer(&lpszCompStr[0])),
|
|
0)
|
|
return int32(ret1)
|
|
}
|
|
|
|
func StrCpyNW(dst LPWSTR, src string, count int32) LPWSTR {
|
|
srcStr := unicode16FromString(src)
|
|
ret1 := syscall3(strCpyNW, 3,
|
|
uintptr(unsafe.Pointer(dst)),
|
|
uintptr(unsafe.Pointer(&srcStr[0])),
|
|
uintptr(count))
|
|
return (LPWSTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func StrCpyW(lpszStr LPWSTR, lpszSrc string) LPWSTR {
|
|
lpszSrcStr := unicode16FromString(lpszSrc)
|
|
ret1 := syscall3(strCpyW, 2,
|
|
uintptr(unsafe.Pointer(lpszStr)),
|
|
uintptr(unsafe.Pointer(&lpszSrcStr[0])),
|
|
0)
|
|
return (LPWSTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func StrDup(lpszStr string) LPWSTR {
|
|
lpszStrStr := unicode16FromString(lpszStr)
|
|
ret1 := syscall3(strDup, 1,
|
|
uintptr(unsafe.Pointer(&lpszStrStr[0])),
|
|
0,
|
|
0)
|
|
return (LPWSTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func StrFormatByteSize64A(llBytes LONGLONG, lpszDest LPSTR, cchMax UINT) LPSTR {
|
|
ret1 := syscall3(strFormatByteSize64A, 3,
|
|
uintptr(llBytes),
|
|
uintptr(unsafe.Pointer(lpszDest)),
|
|
uintptr(cchMax))
|
|
return (LPSTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func StrFormatByteSize(llBytes LONGLONG, lpszDest LPWSTR, cchMax UINT) LPWSTR {
|
|
ret1 := syscall3(strFormatByteSize, 3,
|
|
uintptr(llBytes),
|
|
uintptr(unsafe.Pointer(lpszDest)),
|
|
uintptr(cchMax))
|
|
return (LPWSTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func StrFormatKBSize(llBytes LONGLONG, lpszDest LPWSTR, cchMax UINT) LPWSTR {
|
|
ret1 := syscall3(strFormatKBSize, 3,
|
|
uintptr(llBytes),
|
|
uintptr(unsafe.Pointer(lpszDest)),
|
|
uintptr(cchMax))
|
|
return (LPWSTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func StrFromTimeInterval(lpszStr LPWSTR, cchMax UINT, dwMS DWORD, iDigits int32) INT {
|
|
ret1 := syscall6(strFromTimeInterval, 4,
|
|
uintptr(unsafe.Pointer(lpszStr)),
|
|
uintptr(cchMax),
|
|
uintptr(dwMS),
|
|
uintptr(iDigits),
|
|
0,
|
|
0)
|
|
return INT(ret1)
|
|
}
|
|
|
|
func StrIsIntlEqual(bCase bool, lpszStr string, lpszComp string, iLen int32) bool {
|
|
lpszStrStr := unicode16FromString(lpszStr)
|
|
lpszCompStr := unicode16FromString(lpszComp)
|
|
ret1 := syscall6(strIsIntlEqual, 4,
|
|
getUintptrFromBool(bCase),
|
|
uintptr(unsafe.Pointer(&lpszStrStr[0])),
|
|
uintptr(unsafe.Pointer(&lpszCompStr[0])),
|
|
uintptr(iLen),
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func StrNCat(lpszStr LPWSTR, lpszCat string, cchMax INT) LPWSTR {
|
|
lpszCatStr := unicode16FromString(lpszCat)
|
|
ret1 := syscall3(strNCat, 3,
|
|
uintptr(unsafe.Pointer(lpszStr)),
|
|
uintptr(unsafe.Pointer(&lpszCatStr[0])),
|
|
uintptr(cchMax))
|
|
return (LPWSTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func StrPBrk(lpszStr string, lpszMatch string) LPWSTR {
|
|
lpszStrStr := unicode16FromString(lpszStr)
|
|
lpszMatchStr := unicode16FromString(lpszMatch)
|
|
ret1 := syscall3(strPBrk, 2,
|
|
uintptr(unsafe.Pointer(&lpszStrStr[0])),
|
|
uintptr(unsafe.Pointer(&lpszMatchStr[0])),
|
|
0)
|
|
return (LPWSTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func StrRChrI(str string, end string, ch WORD) LPWSTR {
|
|
strStr := unicode16FromString(str)
|
|
endStr := unicode16FromString(end)
|
|
ret1 := syscall3(strRChrI, 3,
|
|
uintptr(unsafe.Pointer(&strStr[0])),
|
|
uintptr(unsafe.Pointer(&endStr[0])),
|
|
uintptr(ch))
|
|
return (LPWSTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func StrRChr(str string, end string, ch WORD) LPWSTR {
|
|
strStr := unicode16FromString(str)
|
|
endStr := unicode16FromString(end)
|
|
ret1 := syscall3(strRChr, 3,
|
|
uintptr(unsafe.Pointer(&strStr[0])),
|
|
uintptr(unsafe.Pointer(&endStr[0])),
|
|
uintptr(ch))
|
|
return (LPWSTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func StrRStrI(lpszStr string, lpszEnd string, lpszSearch string) LPWSTR {
|
|
lpszStrStr := unicode16FromString(lpszStr)
|
|
lpszEndStr := unicode16FromString(lpszEnd)
|
|
lpszSearchStr := unicode16FromString(lpszSearch)
|
|
ret1 := syscall3(strRStrI, 3,
|
|
uintptr(unsafe.Pointer(&lpszStrStr[0])),
|
|
uintptr(unsafe.Pointer(&lpszEndStr[0])),
|
|
uintptr(unsafe.Pointer(&lpszSearchStr[0])))
|
|
return (LPWSTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func StrRetToBSTR(lpStrRet *STRRET, pidl /*const*/ LPCITEMIDLIST, pBstrOut *BSTR) HRESULT {
|
|
ret1 := syscall3(strRetToBSTR, 3,
|
|
uintptr(unsafe.Pointer(lpStrRet)),
|
|
uintptr(unsafe.Pointer(pidl)),
|
|
uintptr(unsafe.Pointer(pBstrOut)))
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func StrRetToBuf(src *STRRET, pidl /*const*/ *ITEMIDLIST, dest LPWSTR, aLen UINT) HRESULT {
|
|
ret1 := syscall6(strRetToBuf, 4,
|
|
uintptr(unsafe.Pointer(src)),
|
|
uintptr(unsafe.Pointer(pidl)),
|
|
uintptr(unsafe.Pointer(dest)),
|
|
uintptr(aLen),
|
|
0,
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func StrRetToStr(lpStrRet *STRRET, pidl /*const*/ *ITEMIDLIST, ppszName *LPWSTR) HRESULT {
|
|
ret1 := syscall3(strRetToStr, 3,
|
|
uintptr(unsafe.Pointer(lpStrRet)),
|
|
uintptr(unsafe.Pointer(pidl)),
|
|
uintptr(unsafe.Pointer(ppszName)))
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func StrSpn(lpszStr string, lpszMatch string) int32 {
|
|
lpszStrStr := unicode16FromString(lpszStr)
|
|
lpszMatchStr := unicode16FromString(lpszMatch)
|
|
ret1 := syscall3(strSpn, 2,
|
|
uintptr(unsafe.Pointer(&lpszStrStr[0])),
|
|
uintptr(unsafe.Pointer(&lpszMatchStr[0])),
|
|
0)
|
|
return int32(ret1)
|
|
}
|
|
|
|
func StrStrI(lpszStr string, lpszSearch string) LPWSTR {
|
|
lpszStrStr := unicode16FromString(lpszStr)
|
|
lpszSearchStr := unicode16FromString(lpszSearch)
|
|
ret1 := syscall3(strStrI, 2,
|
|
uintptr(unsafe.Pointer(&lpszStrStr[0])),
|
|
uintptr(unsafe.Pointer(&lpszSearchStr[0])),
|
|
0)
|
|
return (LPWSTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func StrStrNIW(lpFirst string, lpSrch string, cchMax UINT) LPWSTR {
|
|
lpFirstStr := unicode16FromString(lpFirst)
|
|
lpSrchStr := unicode16FromString(lpSrch)
|
|
ret1 := syscall3(strStrNIW, 3,
|
|
uintptr(unsafe.Pointer(&lpFirstStr[0])),
|
|
uintptr(unsafe.Pointer(&lpSrchStr[0])),
|
|
uintptr(cchMax))
|
|
return (LPWSTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func StrStrNW(lpFirst string, lpSrch string, cchMax UINT) LPWSTR {
|
|
lpFirstStr := unicode16FromString(lpFirst)
|
|
lpSrchStr := unicode16FromString(lpSrch)
|
|
ret1 := syscall3(strStrNW, 3,
|
|
uintptr(unsafe.Pointer(&lpFirstStr[0])),
|
|
uintptr(unsafe.Pointer(&lpSrchStr[0])),
|
|
uintptr(cchMax))
|
|
return (LPWSTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func StrStr(lpszStr string, lpszSearch string) LPWSTR {
|
|
lpszStrStr := unicode16FromString(lpszStr)
|
|
lpszSearchStr := unicode16FromString(lpszSearch)
|
|
ret1 := syscall3(strStr, 2,
|
|
uintptr(unsafe.Pointer(&lpszStrStr[0])),
|
|
uintptr(unsafe.Pointer(&lpszSearchStr[0])),
|
|
0)
|
|
return (LPWSTR)(unsafe.Pointer(ret1))
|
|
}
|
|
|
|
func StrToInt64Ex(lpszStr string, dwFlags DWORD, lpiRet *LONGLONG) bool {
|
|
lpszStrStr := unicode16FromString(lpszStr)
|
|
ret1 := syscall3(strToInt64Ex, 3,
|
|
uintptr(unsafe.Pointer(&lpszStrStr[0])),
|
|
uintptr(dwFlags),
|
|
uintptr(unsafe.Pointer(lpiRet)))
|
|
return ret1 != 0
|
|
}
|
|
|
|
func StrToIntEx(lpszStr string, dwFlags DWORD, lpiRet *int32) bool {
|
|
lpszStrStr := unicode16FromString(lpszStr)
|
|
ret1 := syscall3(strToIntEx, 3,
|
|
uintptr(unsafe.Pointer(&lpszStrStr[0])),
|
|
uintptr(dwFlags),
|
|
uintptr(unsafe.Pointer(lpiRet)))
|
|
return ret1 != 0
|
|
}
|
|
|
|
func StrToInt(lpString string) INT {
|
|
lpStringStr := unicode16FromString(lpString)
|
|
ret1 := syscall3(strToInt, 1,
|
|
uintptr(unsafe.Pointer(&lpStringStr[0])),
|
|
0,
|
|
0)
|
|
return INT(ret1)
|
|
}
|
|
|
|
func StrTrim(lpszStr LPWSTR, lpszTrim string) bool {
|
|
lpszTrimStr := unicode16FromString(lpszTrim)
|
|
ret1 := syscall3(strTrim, 2,
|
|
uintptr(unsafe.Pointer(lpszStr)),
|
|
uintptr(unsafe.Pointer(&lpszTrimStr[0])),
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func UrlApplyScheme(pszIn string, pszOut LPWSTR, pcchOut *uint32, dwFlags DWORD) HRESULT {
|
|
pszInStr := unicode16FromString(pszIn)
|
|
ret1 := syscall6(urlApplyScheme, 4,
|
|
uintptr(unsafe.Pointer(&pszInStr[0])),
|
|
uintptr(unsafe.Pointer(pszOut)),
|
|
uintptr(unsafe.Pointer(pcchOut)),
|
|
uintptr(dwFlags),
|
|
0,
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func UrlCanonicalize(pszUrl string, pszCanonicalized LPWSTR, pcchCanonicalized *uint32, dwFlags DWORD) HRESULT {
|
|
pszUrlStr := unicode16FromString(pszUrl)
|
|
ret1 := syscall6(urlCanonicalize, 4,
|
|
uintptr(unsafe.Pointer(&pszUrlStr[0])),
|
|
uintptr(unsafe.Pointer(pszCanonicalized)),
|
|
uintptr(unsafe.Pointer(pcchCanonicalized)),
|
|
uintptr(dwFlags),
|
|
0,
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func UrlCombine(pszBase string, pszRelative string, pszCombined LPWSTR, pcchCombined *uint32, dwFlags DWORD) HRESULT {
|
|
pszBaseStr := unicode16FromString(pszBase)
|
|
pszRelativeStr := unicode16FromString(pszRelative)
|
|
ret1 := syscall6(urlCombine, 5,
|
|
uintptr(unsafe.Pointer(&pszBaseStr[0])),
|
|
uintptr(unsafe.Pointer(&pszRelativeStr[0])),
|
|
uintptr(unsafe.Pointer(pszCombined)),
|
|
uintptr(unsafe.Pointer(pcchCombined)),
|
|
uintptr(dwFlags),
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func UrlCompare(pszUrl1 string, pszUrl2 string, fIgnoreSlash bool) INT {
|
|
pszUrl1Str := unicode16FromString(pszUrl1)
|
|
pszUrl2Str := unicode16FromString(pszUrl2)
|
|
ret1 := syscall3(urlCompare, 3,
|
|
uintptr(unsafe.Pointer(&pszUrl1Str[0])),
|
|
uintptr(unsafe.Pointer(&pszUrl2Str[0])),
|
|
getUintptrFromBool(fIgnoreSlash))
|
|
return INT(ret1)
|
|
}
|
|
|
|
func UrlCreateFromPath(pszPath string, pszUrl LPWSTR, pcchUrl *uint32, dwReserved DWORD) HRESULT {
|
|
pszPathStr := unicode16FromString(pszPath)
|
|
ret1 := syscall6(urlCreateFromPath, 4,
|
|
uintptr(unsafe.Pointer(&pszPathStr[0])),
|
|
uintptr(unsafe.Pointer(pszUrl)),
|
|
uintptr(unsafe.Pointer(pcchUrl)),
|
|
uintptr(dwReserved),
|
|
0,
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func UrlEscape(pszUrl string, pszEscaped LPWSTR, pcchEscaped *uint32, dwFlags DWORD) HRESULT {
|
|
pszUrlStr := unicode16FromString(pszUrl)
|
|
ret1 := syscall6(urlEscape, 4,
|
|
uintptr(unsafe.Pointer(&pszUrlStr[0])),
|
|
uintptr(unsafe.Pointer(pszEscaped)),
|
|
uintptr(unsafe.Pointer(pcchEscaped)),
|
|
uintptr(dwFlags),
|
|
0,
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func UrlFixupW(url string, translatedUrl LPWSTR, maxChars DWORD) HRESULT {
|
|
urlStr := unicode16FromString(url)
|
|
ret1 := syscall3(urlFixupW, 3,
|
|
uintptr(unsafe.Pointer(&urlStr[0])),
|
|
uintptr(unsafe.Pointer(translatedUrl)),
|
|
uintptr(maxChars))
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func UrlGetLocation(pszUrl string) string {
|
|
pszUrlStr := unicode16FromString(pszUrl)
|
|
ret1 := syscall3(urlGetLocation, 1,
|
|
uintptr(unsafe.Pointer(&pszUrlStr[0])),
|
|
0,
|
|
0)
|
|
return stringFromUnicode16((*uint16)(unsafe.Pointer(ret1)))
|
|
}
|
|
|
|
func UrlGetPart(pszIn string, pszOut LPWSTR, pcchOut *uint32, dwPart DWORD, dwFlags DWORD) HRESULT {
|
|
pszInStr := unicode16FromString(pszIn)
|
|
ret1 := syscall6(urlGetPart, 5,
|
|
uintptr(unsafe.Pointer(&pszInStr[0])),
|
|
uintptr(unsafe.Pointer(pszOut)),
|
|
uintptr(unsafe.Pointer(pcchOut)),
|
|
uintptr(dwPart),
|
|
uintptr(dwFlags),
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func UrlHash(pszUrl string, lpDest *byte, nDestLen DWORD) HRESULT {
|
|
pszUrlStr := unicode16FromString(pszUrl)
|
|
ret1 := syscall3(urlHash, 3,
|
|
uintptr(unsafe.Pointer(&pszUrlStr[0])),
|
|
uintptr(unsafe.Pointer(lpDest)),
|
|
uintptr(nDestLen))
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func UrlIsNoHistory(pszUrl string) bool {
|
|
pszUrlStr := unicode16FromString(pszUrl)
|
|
ret1 := syscall3(urlIsNoHistory, 1,
|
|
uintptr(unsafe.Pointer(&pszUrlStr[0])),
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func UrlIsOpaque(pszUrl string) bool {
|
|
pszUrlStr := unicode16FromString(pszUrl)
|
|
ret1 := syscall3(urlIsOpaque, 1,
|
|
uintptr(unsafe.Pointer(&pszUrlStr[0])),
|
|
0,
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func UrlIs(pszUrl string, urlis URLIS) bool {
|
|
pszUrlStr := unicode16FromString(pszUrl)
|
|
ret1 := syscall3(urlIs, 2,
|
|
uintptr(unsafe.Pointer(&pszUrlStr[0])),
|
|
uintptr(urlis),
|
|
0)
|
|
return ret1 != 0
|
|
}
|
|
|
|
func UrlUnescape(pszUrl LPWSTR, pszUnescaped LPWSTR, pcchUnescaped *uint32, dwFlags DWORD) HRESULT {
|
|
ret1 := syscall6(urlUnescape, 4,
|
|
uintptr(unsafe.Pointer(pszUrl)),
|
|
uintptr(unsafe.Pointer(pszUnescaped)),
|
|
uintptr(unsafe.Pointer(pcchUnescaped)),
|
|
uintptr(dwFlags),
|
|
0,
|
|
0)
|
|
return HRESULT(ret1)
|
|
}
|
|
|
|
func WhichPlatform() DWORD {
|
|
ret1 := syscall3(whichPlatform, 0,
|
|
0,
|
|
0,
|
|
0)
|
|
return DWORD(ret1)
|
|
}
|