github.com/kbinani/win@v0.3.0/ole32.go (about) 1 // This file was automatically generated by https://github.com/kbinani/win/blob/generator/internal/cmd/gen/gen.go 2 // go run internal/cmd/gen/gen.go 3 4 // +build windows 5 6 package win 7 8 import ( 9 "unsafe" 10 ) 11 12 var ( 13 // Library 14 libole32 uintptr 15 16 // Functions 17 coGetInterceptor uintptr 18 coGetInterceptorFromTypeInfo uintptr 19 propVariantChangeType uintptr 20 bindMoniker uintptr 21 cLSIDFromProgIDEx uintptr 22 cLSIDFromString uintptr 23 coAddRefServerProcess uintptr 24 coAllowSetForegroundWindow uintptr 25 coBuildVersion uintptr 26 coCopyProxy uintptr 27 coCreateFreeThreadedMarshaler uintptr 28 coCreateGuid uintptr 29 coDisconnectObject uintptr 30 coFileTimeNow uintptr 31 coFreeAllLibraries uintptr 32 coFreeLibrary uintptr 33 coGetActivationState uintptr 34 coGetApartmentType uintptr 35 coGetCallContext uintptr 36 coGetCallState uintptr 37 coGetCallerTID uintptr 38 coGetContextToken uintptr 39 coGetCurrentLogicalThreadId uintptr 40 coGetCurrentProcess uintptr 41 coGetDefaultContext uintptr 42 coGetInstanceFromIStorage uintptr 43 coGetInterfaceAndReleaseStream uintptr 44 coGetMalloc uintptr 45 coGetMarshalSizeMax uintptr 46 coGetObject uintptr 47 coGetObjectContext uintptr 48 coGetPSClsid uintptr 49 coGetStandardMarshal uintptr 50 coGetState uintptr 51 coGetTreatAsClass uintptr 52 coImpersonateClient uintptr 53 coInitialize uintptr 54 coInitializeSecurity uintptr 55 coInitializeWOW uintptr 56 coIsHandlerConnected uintptr 57 coIsOle1Class uintptr 58 coLoadLibrary uintptr 59 coLockObjectExternal uintptr 60 coMarshalHresult uintptr 61 coMarshalInterThreadInterfaceInStream uintptr 62 coMarshalInterface uintptr 63 coQueryClientBlanket uintptr 64 coQueryProxyBlanket uintptr 65 coRegisterChannelHook uintptr 66 coRegisterClassObject uintptr 67 coRegisterInitializeSpy uintptr 68 coRegisterMallocSpy uintptr 69 coRegisterMessageFilter uintptr 70 coRegisterPSClsid uintptr 71 coReleaseMarshalData uintptr 72 coReleaseServerProcess uintptr 73 coResumeClassObjects uintptr 74 coRevertToSelf uintptr 75 coRevokeInitializeSpy uintptr 76 coRevokeMallocSpy uintptr 77 coSetProxyBlanket uintptr 78 coSetState uintptr 79 coSuspendClassObjects uintptr 80 coSwitchCallContext uintptr 81 coTaskMemAlloc uintptr 82 coTaskMemFree uintptr 83 coTaskMemRealloc uintptr 84 coTreatAsClass uintptr 85 coUnmarshalHresult uintptr 86 coUnmarshalInterface uintptr 87 coWaitForMultipleHandles uintptr 88 createAntiMoniker uintptr 89 createBindCtx uintptr 90 createClassMoniker uintptr 91 createDataAdviseHolder uintptr 92 createDataCache uintptr 93 createFileMoniker uintptr 94 createGenericComposite uintptr 95 createILockBytesOnHGlobal uintptr 96 createItemMoniker uintptr 97 createOleAdviseHolder uintptr 98 createPointerMoniker uintptr 99 createStreamOnHGlobal uintptr 100 dllDebugObjectRPCHook uintptr 101 doDragDrop uintptr 102 fmtIdToPropStgName uintptr 103 freePropVariantArray uintptr 104 getClassFile uintptr 105 getConvertStg uintptr 106 getHGlobalFromILockBytes uintptr 107 getHGlobalFromStream uintptr 108 getRunningObjectTable uintptr 109 iIDFromString uintptr 110 isAccelerator uintptr 111 isEqualGUID uintptr 112 isValidInterface uintptr 113 mkParseDisplayName uintptr 114 monikerCommonPrefixWith uintptr 115 oleBuildVersion uintptr 116 oleConvertIStorageToOLESTREAM uintptr 117 oleConvertOLESTREAMToIStorage uintptr 118 oleCreate uintptr 119 oleCreateDefaultHandler uintptr 120 oleCreateEmbeddingHelper uintptr 121 oleCreateFromData uintptr 122 oleCreateFromDataEx uintptr 123 oleCreateFromFile uintptr 124 oleCreateFromFileEx uintptr 125 oleCreateLink uintptr 126 oleCreateLinkFromData uintptr 127 oleCreateLinkToFile uintptr 128 oleCreateMenuDescriptor uintptr 129 oleCreateStaticFromData uintptr 130 oleDestroyMenuDescriptor uintptr 131 oleDoAutoConvert uintptr 132 oleDraw uintptr 133 oleDuplicateData uintptr 134 oleFlushClipboard uintptr 135 oleGetAutoConvert uintptr 136 oleGetClipboard uintptr 137 oleGetIconOfClass uintptr 138 oleInitializeWOW uintptr 139 oleIsCurrentClipboard uintptr 140 oleIsRunning uintptr 141 oleLoad uintptr 142 oleLoadFromStream uintptr 143 oleLockRunning uintptr 144 oleMetafilePictFromIconAndLabel uintptr 145 oleNoteObjectVisible uintptr 146 oleQueryCreateFromData uintptr 147 oleQueryLinkFromData uintptr 148 oleRegEnumVerbs uintptr 149 oleRegGetMiscStatus uintptr 150 oleRegGetUserType uintptr 151 oleSave uintptr 152 oleSaveToStream uintptr 153 oleSetAutoConvert uintptr 154 oleSetClipboard uintptr 155 oleSetContainedObject uintptr 156 oleSetMenuDescriptor uintptr 157 oleTranslateAccelerator uintptr 158 propStgNameToFmtId uintptr 159 propSysAllocString uintptr 160 propSysFreeString uintptr 161 propVariantClear uintptr 162 propVariantCopy uintptr 163 readClassStg uintptr 164 readClassStm uintptr 165 readFmtUserTypeStg uintptr 166 registerDragDrop uintptr 167 releaseStgMedium uintptr 168 revokeDragDrop uintptr 169 setConvertStg uintptr 170 stgCreateDocfile uintptr 171 stgCreateDocfileOnILockBytes uintptr 172 stgCreatePropSetStg uintptr 173 stgCreatePropStg uintptr 174 stgIsStorageFile uintptr 175 stgIsStorageILockBytes uintptr 176 stgOpenPropStg uintptr 177 stgSetTimes uintptr 178 stringFromCLSID uintptr 179 stringFromGUID2 uintptr 180 wdtpInterfacePointer_UserFree uintptr 181 writeClassStg uintptr 182 writeClassStm uintptr 183 writeFmtUserTypeStg uintptr 184 ) 185 186 func init() { 187 // Library 188 libole32 = doLoadLibrary("ole32.dll") 189 190 // Functions 191 coGetInterceptor = doGetProcAddress(libole32, "CoGetInterceptor") 192 coGetInterceptorFromTypeInfo = doGetProcAddress(libole32, "CoGetInterceptorFromTypeInfo") 193 propVariantChangeType = doGetProcAddress(libole32, "PropVariantChangeType") 194 bindMoniker = doGetProcAddress(libole32, "BindMoniker") 195 cLSIDFromProgIDEx = doGetProcAddress(libole32, "CLSIDFromProgIDEx") 196 cLSIDFromString = doGetProcAddress(libole32, "CLSIDFromString") 197 coAddRefServerProcess = doGetProcAddress(libole32, "CoAddRefServerProcess") 198 coAllowSetForegroundWindow = doGetProcAddress(libole32, "CoAllowSetForegroundWindow") 199 coBuildVersion = doGetProcAddress(libole32, "CoBuildVersion") 200 coCopyProxy = doGetProcAddress(libole32, "CoCopyProxy") 201 coCreateFreeThreadedMarshaler = doGetProcAddress(libole32, "CoCreateFreeThreadedMarshaler") 202 coCreateGuid = doGetProcAddress(libole32, "CoCreateGuid") 203 coDisconnectObject = doGetProcAddress(libole32, "CoDisconnectObject") 204 coFileTimeNow = doGetProcAddress(libole32, "CoFileTimeNow") 205 coFreeAllLibraries = doGetProcAddress(libole32, "CoFreeAllLibraries") 206 coFreeLibrary = doGetProcAddress(libole32, "CoFreeLibrary") 207 coGetActivationState = doGetProcAddress(libole32, "CoGetActivationState") 208 coGetApartmentType = doGetProcAddress(libole32, "CoGetApartmentType") 209 coGetCallContext = doGetProcAddress(libole32, "CoGetCallContext") 210 coGetCallState = doGetProcAddress(libole32, "CoGetCallState") 211 coGetCallerTID = doGetProcAddress(libole32, "CoGetCallerTID") 212 coGetContextToken = doGetProcAddress(libole32, "CoGetContextToken") 213 coGetCurrentLogicalThreadId = doGetProcAddress(libole32, "CoGetCurrentLogicalThreadId") 214 coGetCurrentProcess = doGetProcAddress(libole32, "CoGetCurrentProcess") 215 coGetDefaultContext = doGetProcAddress(libole32, "CoGetDefaultContext") 216 coGetInstanceFromIStorage = doGetProcAddress(libole32, "CoGetInstanceFromIStorage") 217 coGetInterfaceAndReleaseStream = doGetProcAddress(libole32, "CoGetInterfaceAndReleaseStream") 218 coGetMalloc = doGetProcAddress(libole32, "CoGetMalloc") 219 coGetMarshalSizeMax = doGetProcAddress(libole32, "CoGetMarshalSizeMax") 220 coGetObject = doGetProcAddress(libole32, "CoGetObject") 221 coGetObjectContext = doGetProcAddress(libole32, "CoGetObjectContext") 222 coGetPSClsid = doGetProcAddress(libole32, "CoGetPSClsid") 223 coGetStandardMarshal = doGetProcAddress(libole32, "CoGetStandardMarshal") 224 coGetState = doGetProcAddress(libole32, "CoGetState") 225 coGetTreatAsClass = doGetProcAddress(libole32, "CoGetTreatAsClass") 226 coImpersonateClient = doGetProcAddress(libole32, "CoImpersonateClient") 227 coInitialize = doGetProcAddress(libole32, "CoInitialize") 228 coInitializeSecurity = doGetProcAddress(libole32, "CoInitializeSecurity") 229 coInitializeWOW = doGetProcAddress(libole32, "CoInitializeWOW") 230 coIsHandlerConnected = doGetProcAddress(libole32, "CoIsHandlerConnected") 231 coIsOle1Class = doGetProcAddress(libole32, "CoIsOle1Class") 232 coLoadLibrary = doGetProcAddress(libole32, "CoLoadLibrary") 233 coLockObjectExternal = doGetProcAddress(libole32, "CoLockObjectExternal") 234 coMarshalHresult = doGetProcAddress(libole32, "CoMarshalHresult") 235 coMarshalInterThreadInterfaceInStream = doGetProcAddress(libole32, "CoMarshalInterThreadInterfaceInStream") 236 coMarshalInterface = doGetProcAddress(libole32, "CoMarshalInterface") 237 coQueryClientBlanket = doGetProcAddress(libole32, "CoQueryClientBlanket") 238 coQueryProxyBlanket = doGetProcAddress(libole32, "CoQueryProxyBlanket") 239 coRegisterChannelHook = doGetProcAddress(libole32, "CoRegisterChannelHook") 240 coRegisterClassObject = doGetProcAddress(libole32, "CoRegisterClassObject") 241 coRegisterInitializeSpy = doGetProcAddress(libole32, "CoRegisterInitializeSpy") 242 coRegisterMallocSpy = doGetProcAddress(libole32, "CoRegisterMallocSpy") 243 coRegisterMessageFilter = doGetProcAddress(libole32, "CoRegisterMessageFilter") 244 coRegisterPSClsid = doGetProcAddress(libole32, "CoRegisterPSClsid") 245 coReleaseMarshalData = doGetProcAddress(libole32, "CoReleaseMarshalData") 246 coReleaseServerProcess = doGetProcAddress(libole32, "CoReleaseServerProcess") 247 coResumeClassObjects = doGetProcAddress(libole32, "CoResumeClassObjects") 248 coRevertToSelf = doGetProcAddress(libole32, "CoRevertToSelf") 249 coRevokeInitializeSpy = doGetProcAddress(libole32, "CoRevokeInitializeSpy") 250 coRevokeMallocSpy = doGetProcAddress(libole32, "CoRevokeMallocSpy") 251 coSetProxyBlanket = doGetProcAddress(libole32, "CoSetProxyBlanket") 252 coSetState = doGetProcAddress(libole32, "CoSetState") 253 coSuspendClassObjects = doGetProcAddress(libole32, "CoSuspendClassObjects") 254 coSwitchCallContext = doGetProcAddress(libole32, "CoSwitchCallContext") 255 coTaskMemAlloc = doGetProcAddress(libole32, "CoTaskMemAlloc") 256 coTaskMemFree = doGetProcAddress(libole32, "CoTaskMemFree") 257 coTaskMemRealloc = doGetProcAddress(libole32, "CoTaskMemRealloc") 258 coTreatAsClass = doGetProcAddress(libole32, "CoTreatAsClass") 259 coUnmarshalHresult = doGetProcAddress(libole32, "CoUnmarshalHresult") 260 coUnmarshalInterface = doGetProcAddress(libole32, "CoUnmarshalInterface") 261 coWaitForMultipleHandles = doGetProcAddress(libole32, "CoWaitForMultipleHandles") 262 createAntiMoniker = doGetProcAddress(libole32, "CreateAntiMoniker") 263 createBindCtx = doGetProcAddress(libole32, "CreateBindCtx") 264 createClassMoniker = doGetProcAddress(libole32, "CreateClassMoniker") 265 createDataAdviseHolder = doGetProcAddress(libole32, "CreateDataAdviseHolder") 266 createDataCache = doGetProcAddress(libole32, "CreateDataCache") 267 createFileMoniker = doGetProcAddress(libole32, "CreateFileMoniker") 268 createGenericComposite = doGetProcAddress(libole32, "CreateGenericComposite") 269 createILockBytesOnHGlobal = doGetProcAddress(libole32, "CreateILockBytesOnHGlobal") 270 createItemMoniker = doGetProcAddress(libole32, "CreateItemMoniker") 271 createOleAdviseHolder = doGetProcAddress(libole32, "CreateOleAdviseHolder") 272 createPointerMoniker = doGetProcAddress(libole32, "CreatePointerMoniker") 273 createStreamOnHGlobal = doGetProcAddress(libole32, "CreateStreamOnHGlobal") 274 dllDebugObjectRPCHook = doGetProcAddress(libole32, "DllDebugObjectRPCHook") 275 doDragDrop = doGetProcAddress(libole32, "DoDragDrop") 276 fmtIdToPropStgName = doGetProcAddress(libole32, "FmtIdToPropStgName") 277 freePropVariantArray = doGetProcAddress(libole32, "FreePropVariantArray") 278 getClassFile = doGetProcAddress(libole32, "GetClassFile") 279 getConvertStg = doGetProcAddress(libole32, "GetConvertStg") 280 getHGlobalFromILockBytes = doGetProcAddress(libole32, "GetHGlobalFromILockBytes") 281 getHGlobalFromStream = doGetProcAddress(libole32, "GetHGlobalFromStream") 282 getRunningObjectTable = doGetProcAddress(libole32, "GetRunningObjectTable") 283 iIDFromString = doGetProcAddress(libole32, "IIDFromString") 284 isAccelerator = doGetProcAddress(libole32, "IsAccelerator") 285 isEqualGUID = doGetProcAddress(libole32, "IsEqualGUID") 286 isValidInterface = doGetProcAddress(libole32, "IsValidInterface") 287 mkParseDisplayName = doGetProcAddress(libole32, "MkParseDisplayName") 288 monikerCommonPrefixWith = doGetProcAddress(libole32, "MonikerCommonPrefixWith") 289 oleBuildVersion = doGetProcAddress(libole32, "OleBuildVersion") 290 oleConvertIStorageToOLESTREAM = doGetProcAddress(libole32, "OleConvertIStorageToOLESTREAM") 291 oleConvertOLESTREAMToIStorage = doGetProcAddress(libole32, "OleConvertOLESTREAMToIStorage") 292 oleCreate = doGetProcAddress(libole32, "OleCreate") 293 oleCreateDefaultHandler = doGetProcAddress(libole32, "OleCreateDefaultHandler") 294 oleCreateEmbeddingHelper = doGetProcAddress(libole32, "OleCreateEmbeddingHelper") 295 oleCreateFromData = doGetProcAddress(libole32, "OleCreateFromData") 296 oleCreateFromDataEx = doGetProcAddress(libole32, "OleCreateFromDataEx") 297 oleCreateFromFile = doGetProcAddress(libole32, "OleCreateFromFile") 298 oleCreateFromFileEx = doGetProcAddress(libole32, "OleCreateFromFileEx") 299 oleCreateLink = doGetProcAddress(libole32, "OleCreateLink") 300 oleCreateLinkFromData = doGetProcAddress(libole32, "OleCreateLinkFromData") 301 oleCreateLinkToFile = doGetProcAddress(libole32, "OleCreateLinkToFile") 302 oleCreateMenuDescriptor = doGetProcAddress(libole32, "OleCreateMenuDescriptor") 303 oleCreateStaticFromData = doGetProcAddress(libole32, "OleCreateStaticFromData") 304 oleDestroyMenuDescriptor = doGetProcAddress(libole32, "OleDestroyMenuDescriptor") 305 oleDoAutoConvert = doGetProcAddress(libole32, "OleDoAutoConvert") 306 oleDraw = doGetProcAddress(libole32, "OleDraw") 307 oleDuplicateData = doGetProcAddress(libole32, "OleDuplicateData") 308 oleFlushClipboard = doGetProcAddress(libole32, "OleFlushClipboard") 309 oleGetAutoConvert = doGetProcAddress(libole32, "OleGetAutoConvert") 310 oleGetClipboard = doGetProcAddress(libole32, "OleGetClipboard") 311 oleGetIconOfClass = doGetProcAddress(libole32, "OleGetIconOfClass") 312 oleInitializeWOW = doGetProcAddress(libole32, "OleInitializeWOW") 313 oleIsCurrentClipboard = doGetProcAddress(libole32, "OleIsCurrentClipboard") 314 oleIsRunning = doGetProcAddress(libole32, "OleIsRunning") 315 oleLoad = doGetProcAddress(libole32, "OleLoad") 316 oleLoadFromStream = doGetProcAddress(libole32, "OleLoadFromStream") 317 oleLockRunning = doGetProcAddress(libole32, "OleLockRunning") 318 oleMetafilePictFromIconAndLabel = doGetProcAddress(libole32, "OleMetafilePictFromIconAndLabel") 319 oleNoteObjectVisible = doGetProcAddress(libole32, "OleNoteObjectVisible") 320 oleQueryCreateFromData = doGetProcAddress(libole32, "OleQueryCreateFromData") 321 oleQueryLinkFromData = doGetProcAddress(libole32, "OleQueryLinkFromData") 322 oleRegEnumVerbs = doGetProcAddress(libole32, "OleRegEnumVerbs") 323 oleRegGetMiscStatus = doGetProcAddress(libole32, "OleRegGetMiscStatus") 324 oleRegGetUserType = doGetProcAddress(libole32, "OleRegGetUserType") 325 oleSave = doGetProcAddress(libole32, "OleSave") 326 oleSaveToStream = doGetProcAddress(libole32, "OleSaveToStream") 327 oleSetAutoConvert = doGetProcAddress(libole32, "OleSetAutoConvert") 328 oleSetClipboard = doGetProcAddress(libole32, "OleSetClipboard") 329 oleSetContainedObject = doGetProcAddress(libole32, "OleSetContainedObject") 330 oleSetMenuDescriptor = doGetProcAddress(libole32, "OleSetMenuDescriptor") 331 oleTranslateAccelerator = doGetProcAddress(libole32, "OleTranslateAccelerator") 332 propStgNameToFmtId = doGetProcAddress(libole32, "PropStgNameToFmtId") 333 propSysAllocString = doGetProcAddress(libole32, "PropSysAllocString") 334 propSysFreeString = doGetProcAddress(libole32, "PropSysFreeString") 335 propVariantClear = doGetProcAddress(libole32, "PropVariantClear") 336 propVariantCopy = doGetProcAddress(libole32, "PropVariantCopy") 337 readClassStg = doGetProcAddress(libole32, "ReadClassStg") 338 readClassStm = doGetProcAddress(libole32, "ReadClassStm") 339 readFmtUserTypeStg = doGetProcAddress(libole32, "ReadFmtUserTypeStg") 340 registerDragDrop = doGetProcAddress(libole32, "RegisterDragDrop") 341 releaseStgMedium = doGetProcAddress(libole32, "ReleaseStgMedium") 342 revokeDragDrop = doGetProcAddress(libole32, "RevokeDragDrop") 343 setConvertStg = doGetProcAddress(libole32, "SetConvertStg") 344 stgCreateDocfile = doGetProcAddress(libole32, "StgCreateDocfile") 345 stgCreateDocfileOnILockBytes = doGetProcAddress(libole32, "StgCreateDocfileOnILockBytes") 346 stgCreatePropSetStg = doGetProcAddress(libole32, "StgCreatePropSetStg") 347 stgCreatePropStg = doGetProcAddress(libole32, "StgCreatePropStg") 348 stgIsStorageFile = doGetProcAddress(libole32, "StgIsStorageFile") 349 stgIsStorageILockBytes = doGetProcAddress(libole32, "StgIsStorageILockBytes") 350 stgOpenPropStg = doGetProcAddress(libole32, "StgOpenPropStg") 351 stgSetTimes = doGetProcAddress(libole32, "StgSetTimes") 352 stringFromCLSID = doGetProcAddress(libole32, "StringFromCLSID") 353 stringFromGUID2 = doGetProcAddress(libole32, "StringFromGUID2") 354 wdtpInterfacePointer_UserFree = doGetProcAddress(libole32, "WdtpInterfacePointer_UserFree") 355 writeClassStg = doGetProcAddress(libole32, "WriteClassStg") 356 writeClassStm = doGetProcAddress(libole32, "WriteClassStm") 357 writeFmtUserTypeStg = doGetProcAddress(libole32, "WriteFmtUserTypeStg") 358 } 359 360 func CoGetInterceptor(iidIntercepted REFIID, punkOuter *IUnknown, iid REFIID, ppv uintptr) HRESULT { 361 ret1 := syscall6(coGetInterceptor, 4, 362 uintptr(unsafe.Pointer(iidIntercepted)), 363 uintptr(unsafe.Pointer(punkOuter)), 364 uintptr(unsafe.Pointer(iid)), 365 ppv, 366 0, 367 0) 368 return HRESULT(ret1) 369 } 370 371 func CoGetInterceptorFromTypeInfo(iidIntercepted REFIID, punkOuter *IUnknown, typeInfo *ITypeInfo, iid REFIID, ppv uintptr) HRESULT { 372 ret1 := syscall6(coGetInterceptorFromTypeInfo, 5, 373 uintptr(unsafe.Pointer(iidIntercepted)), 374 uintptr(unsafe.Pointer(punkOuter)), 375 uintptr(unsafe.Pointer(typeInfo)), 376 uintptr(unsafe.Pointer(iid)), 377 ppv, 378 0) 379 return HRESULT(ret1) 380 } 381 382 func PropVariantChangeType(ppropvarDest *PROPVARIANT, propvarSrc REFPROPVARIANT, flags PROPVAR_CHANGE_FLAGS, vt VARTYPE) HRESULT { 383 ret1 := syscall6(propVariantChangeType, 4, 384 uintptr(unsafe.Pointer(ppropvarDest)), 385 uintptr(unsafe.Pointer(propvarSrc)), 386 uintptr(flags), 387 uintptr(vt), 388 0, 389 0) 390 return HRESULT(ret1) 391 } 392 393 func BindMoniker(pmk LPMONIKER, grfOpt DWORD, riid REFIID, ppvResult *LPVOID) HRESULT { 394 ret1 := syscall6(bindMoniker, 4, 395 uintptr(unsafe.Pointer(pmk)), 396 uintptr(grfOpt), 397 uintptr(unsafe.Pointer(riid)), 398 uintptr(unsafe.Pointer(ppvResult)), 399 0, 400 0) 401 return HRESULT(ret1) 402 } 403 404 func CLSIDFromProgIDEx(progid /*const*/ LPCOLESTR, clsid *CLSID) HRESULT { 405 ret1 := syscall3(cLSIDFromProgIDEx, 2, 406 uintptr(unsafe.Pointer(progid)), 407 uintptr(unsafe.Pointer(clsid)), 408 0) 409 return HRESULT(ret1) 410 } 411 412 func CLSIDFromString(idstr /*const*/ LPCOLESTR, id *CLSID) HRESULT { 413 ret1 := syscall3(cLSIDFromString, 2, 414 uintptr(unsafe.Pointer(idstr)), 415 uintptr(unsafe.Pointer(id)), 416 0) 417 return HRESULT(ret1) 418 } 419 420 func CoAddRefServerProcess() ULONG { 421 ret1 := syscall3(coAddRefServerProcess, 0, 422 0, 423 0, 424 0) 425 return ULONG(ret1) 426 } 427 428 func CoAllowSetForegroundWindow(pUnk *IUnknown, pvReserved uintptr) HRESULT { 429 ret1 := syscall3(coAllowSetForegroundWindow, 2, 430 uintptr(unsafe.Pointer(pUnk)), 431 pvReserved, 432 0) 433 return HRESULT(ret1) 434 } 435 436 func CoBuildVersion() DWORD { 437 ret1 := syscall3(coBuildVersion, 0, 438 0, 439 0, 440 0) 441 return DWORD(ret1) 442 } 443 444 func CoCopyProxy(pProxy *IUnknown, ppCopy **IUnknown) HRESULT { 445 ret1 := syscall3(coCopyProxy, 2, 446 uintptr(unsafe.Pointer(pProxy)), 447 uintptr(unsafe.Pointer(ppCopy)), 448 0) 449 return HRESULT(ret1) 450 } 451 452 func CoCreateFreeThreadedMarshaler(punkOuter LPUNKNOWN, ppunkMarshal *LPUNKNOWN) HRESULT { 453 ret1 := syscall3(coCreateFreeThreadedMarshaler, 2, 454 uintptr(unsafe.Pointer(punkOuter)), 455 uintptr(unsafe.Pointer(ppunkMarshal)), 456 0) 457 return HRESULT(ret1) 458 } 459 460 func CoCreateGuid(pguid *GUID) HRESULT { 461 ret1 := syscall3(coCreateGuid, 1, 462 uintptr(unsafe.Pointer(pguid)), 463 0, 464 0) 465 return HRESULT(ret1) 466 } 467 468 func CoDisconnectObject(lpUnk LPUNKNOWN, reserved DWORD) HRESULT { 469 ret1 := syscall3(coDisconnectObject, 2, 470 uintptr(unsafe.Pointer(lpUnk)), 471 uintptr(reserved), 472 0) 473 return HRESULT(ret1) 474 } 475 476 func CoFileTimeNow(lpFileTime *FILETIME) HRESULT { 477 ret1 := syscall3(coFileTimeNow, 1, 478 uintptr(unsafe.Pointer(lpFileTime)), 479 0, 480 0) 481 return HRESULT(ret1) 482 } 483 484 func CoFreeAllLibraries() { 485 syscall3(coFreeAllLibraries, 0, 486 0, 487 0, 488 0) 489 } 490 491 func CoFreeLibrary(hLibrary HINSTANCE) { 492 syscall3(coFreeLibrary, 1, 493 uintptr(hLibrary), 494 0, 495 0) 496 } 497 498 func CoGetActivationState(guid GUID, unknown DWORD, unknown2 *uint32) HRESULT { 499 ret1 := syscall6(coGetActivationState, 6, 500 uintptr(guid.Data1), 501 uintptr((uint32(guid.Data2)<<16)|uint32(guid.Data3)), 502 uintptr((uint32(guid.Data4[0])<<24)|(uint32(guid.Data4[1]<<16))|(uint32(guid.Data4[2]<<8))|uint32(guid.Data4[3])), 503 uintptr((uint32(guid.Data4[4])<<24)|(uint32(guid.Data4[5]<<16))|(uint32(guid.Data4[6]<<8))|uint32(guid.Data4[7])), 504 uintptr(unknown), 505 uintptr(unsafe.Pointer(unknown2))) 506 return HRESULT(ret1) 507 } 508 509 func CoGetApartmentType(aType *APTTYPE, qualifier *APTTYPEQUALIFIER) HRESULT { 510 ret1 := syscall3(coGetApartmentType, 2, 511 uintptr(unsafe.Pointer(aType)), 512 uintptr(unsafe.Pointer(qualifier)), 513 0) 514 return HRESULT(ret1) 515 } 516 517 func CoGetCallContext(riid REFIID, ppv uintptr) HRESULT { 518 ret1 := syscall3(coGetCallContext, 2, 519 uintptr(unsafe.Pointer(riid)), 520 ppv, 521 0) 522 return HRESULT(ret1) 523 } 524 525 func CoGetCallState(unknown int32, unknown2 *uint32) HRESULT { 526 ret1 := syscall3(coGetCallState, 2, 527 uintptr(unknown), 528 uintptr(unsafe.Pointer(unknown2)), 529 0) 530 return HRESULT(ret1) 531 } 532 533 func CoGetCallerTID(lpdwTID *uint32) HRESULT { 534 ret1 := syscall3(coGetCallerTID, 1, 535 uintptr(unsafe.Pointer(lpdwTID)), 536 0, 537 0) 538 return HRESULT(ret1) 539 } 540 541 func CoGetContextToken(token *ULONG_PTR) HRESULT { 542 ret1 := syscall3(coGetContextToken, 1, 543 uintptr(unsafe.Pointer(token)), 544 0, 545 0) 546 return HRESULT(ret1) 547 } 548 549 func CoGetCurrentLogicalThreadId(id *GUID) HRESULT { 550 ret1 := syscall3(coGetCurrentLogicalThreadId, 1, 551 uintptr(unsafe.Pointer(id)), 552 0, 553 0) 554 return HRESULT(ret1) 555 } 556 557 func CoGetCurrentProcess() DWORD { 558 ret1 := syscall3(coGetCurrentProcess, 0, 559 0, 560 0, 561 0) 562 return DWORD(ret1) 563 } 564 565 func CoGetDefaultContext(aType APTTYPE, riid REFIID, ppv *LPVOID) HRESULT { 566 ret1 := syscall3(coGetDefaultContext, 3, 567 uintptr(aType), 568 uintptr(unsafe.Pointer(riid)), 569 uintptr(unsafe.Pointer(ppv))) 570 return HRESULT(ret1) 571 } 572 573 func CoGetInstanceFromIStorage(server_info *COSERVERINFO, rclsid *CLSID, outer *IUnknown, cls_context DWORD, storage *IStorage, count DWORD, results *MULTI_QI) HRESULT { 574 ret1 := syscall9(coGetInstanceFromIStorage, 7, 575 uintptr(unsafe.Pointer(server_info)), 576 uintptr(unsafe.Pointer(rclsid)), 577 uintptr(unsafe.Pointer(outer)), 578 uintptr(cls_context), 579 uintptr(unsafe.Pointer(storage)), 580 uintptr(count), 581 uintptr(unsafe.Pointer(results)), 582 0, 583 0) 584 return HRESULT(ret1) 585 } 586 587 func CoGetInterfaceAndReleaseStream(pStm LPSTREAM, riid REFIID, ppv *LPVOID) HRESULT { 588 ret1 := syscall3(coGetInterfaceAndReleaseStream, 3, 589 uintptr(unsafe.Pointer(pStm)), 590 uintptr(unsafe.Pointer(riid)), 591 uintptr(unsafe.Pointer(ppv))) 592 return HRESULT(ret1) 593 } 594 595 func CoGetMalloc(context DWORD, imalloc **IMalloc) HRESULT { 596 ret1 := syscall3(coGetMalloc, 2, 597 uintptr(context), 598 uintptr(unsafe.Pointer(imalloc)), 599 0) 600 return HRESULT(ret1) 601 } 602 603 func CoGetMarshalSizeMax(pulSize *ULONG, riid REFIID, pUnk *IUnknown, dwDestContext DWORD, pvDestContext uintptr, mshlFlags DWORD) HRESULT { 604 ret1 := syscall6(coGetMarshalSizeMax, 6, 605 uintptr(unsafe.Pointer(pulSize)), 606 uintptr(unsafe.Pointer(riid)), 607 uintptr(unsafe.Pointer(pUnk)), 608 uintptr(dwDestContext), 609 pvDestContext, 610 uintptr(mshlFlags)) 611 return HRESULT(ret1) 612 } 613 614 func CoGetObject(pszName string, pBindOptions *BIND_OPTS, riid REFIID, ppv uintptr) HRESULT { 615 pszNameStr := unicode16FromString(pszName) 616 ret1 := syscall6(coGetObject, 4, 617 uintptr(unsafe.Pointer(&pszNameStr[0])), 618 uintptr(unsafe.Pointer(pBindOptions)), 619 uintptr(unsafe.Pointer(riid)), 620 ppv, 621 0, 622 0) 623 return HRESULT(ret1) 624 } 625 626 func CoGetObjectContext(riid REFIID, ppv uintptr) HRESULT { 627 ret1 := syscall3(coGetObjectContext, 2, 628 uintptr(unsafe.Pointer(riid)), 629 ppv, 630 0) 631 return HRESULT(ret1) 632 } 633 634 func CoGetPSClsid(riid REFIID, pclsid *CLSID) HRESULT { 635 ret1 := syscall3(coGetPSClsid, 2, 636 uintptr(unsafe.Pointer(riid)), 637 uintptr(unsafe.Pointer(pclsid)), 638 0) 639 return HRESULT(ret1) 640 } 641 642 func CoGetStandardMarshal(riid REFIID, pUnk *IUnknown, dwDestContext DWORD, pvDestContext LPVOID, mshlflags DWORD, ppMarshal *LPMARSHAL) HRESULT { 643 ret1 := syscall6(coGetStandardMarshal, 6, 644 uintptr(unsafe.Pointer(riid)), 645 uintptr(unsafe.Pointer(pUnk)), 646 uintptr(dwDestContext), 647 uintptr(unsafe.Pointer(pvDestContext)), 648 uintptr(mshlflags), 649 uintptr(unsafe.Pointer(ppMarshal))) 650 return HRESULT(ret1) 651 } 652 653 func CoGetState(ppv **IUnknown) HRESULT { 654 ret1 := syscall3(coGetState, 1, 655 uintptr(unsafe.Pointer(ppv)), 656 0, 657 0) 658 return HRESULT(ret1) 659 } 660 661 func CoGetTreatAsClass(clsidOld /*const*/ REFCLSID, clsidNew *CLSID) HRESULT { 662 ret1 := syscall3(coGetTreatAsClass, 2, 663 uintptr(unsafe.Pointer(clsidOld)), 664 uintptr(unsafe.Pointer(clsidNew)), 665 0) 666 return HRESULT(ret1) 667 } 668 669 func CoImpersonateClient() HRESULT { 670 ret1 := syscall3(coImpersonateClient, 0, 671 0, 672 0, 673 0) 674 return HRESULT(ret1) 675 } 676 677 func CoInitialize(lpReserved LPVOID) HRESULT { 678 ret1 := syscall3(coInitialize, 1, 679 uintptr(unsafe.Pointer(lpReserved)), 680 0, 681 0) 682 return HRESULT(ret1) 683 } 684 685 func CoInitializeSecurity(pSecDesc PSECURITY_DESCRIPTOR, cAuthSvc LONG, asAuthSvc *SOLE_AUTHENTICATION_SERVICE, pReserved1 uintptr, dwAuthnLevel DWORD, dwImpLevel DWORD, pReserved2 uintptr, dwCapabilities DWORD, pReserved3 uintptr) HRESULT { 686 ret1 := syscall9(coInitializeSecurity, 9, 687 uintptr(unsafe.Pointer(pSecDesc)), 688 uintptr(cAuthSvc), 689 uintptr(unsafe.Pointer(asAuthSvc)), 690 pReserved1, 691 uintptr(dwAuthnLevel), 692 uintptr(dwImpLevel), 693 pReserved2, 694 uintptr(dwCapabilities), 695 pReserved3) 696 return HRESULT(ret1) 697 } 698 699 func CoInitializeWOW(x DWORD, y DWORD) HRESULT { 700 ret1 := syscall3(coInitializeWOW, 2, 701 uintptr(x), 702 uintptr(y), 703 0) 704 return HRESULT(ret1) 705 } 706 707 func CoIsHandlerConnected(pUnk *IUnknown) bool { 708 ret1 := syscall3(coIsHandlerConnected, 1, 709 uintptr(unsafe.Pointer(pUnk)), 710 0, 711 0) 712 return ret1 != 0 713 } 714 715 func CoIsOle1Class(clsid /*const*/ REFCLSID) bool { 716 ret1 := syscall3(coIsOle1Class, 1, 717 uintptr(unsafe.Pointer(clsid)), 718 0, 719 0) 720 return ret1 != 0 721 } 722 723 func CoLoadLibrary(lpszLibName LPOLESTR, bAutoFree bool) HINSTANCE { 724 ret1 := syscall3(coLoadLibrary, 2, 725 uintptr(unsafe.Pointer(lpszLibName)), 726 getUintptrFromBool(bAutoFree), 727 0) 728 return HINSTANCE(ret1) 729 } 730 731 func CoLockObjectExternal(pUnk LPUNKNOWN, fLock bool, fLastUnlockReleases bool) HRESULT { 732 ret1 := syscall3(coLockObjectExternal, 3, 733 uintptr(unsafe.Pointer(pUnk)), 734 getUintptrFromBool(fLock), 735 getUintptrFromBool(fLastUnlockReleases)) 736 return HRESULT(ret1) 737 } 738 739 func CoMarshalHresult(pStm LPSTREAM, hresult HRESULT) HRESULT { 740 ret1 := syscall3(coMarshalHresult, 2, 741 uintptr(unsafe.Pointer(pStm)), 742 uintptr(hresult), 743 0) 744 return HRESULT(ret1) 745 } 746 747 func CoMarshalInterThreadInterfaceInStream(riid REFIID, pUnk LPUNKNOWN, ppStm *LPSTREAM) HRESULT { 748 ret1 := syscall3(coMarshalInterThreadInterfaceInStream, 3, 749 uintptr(unsafe.Pointer(riid)), 750 uintptr(unsafe.Pointer(pUnk)), 751 uintptr(unsafe.Pointer(ppStm))) 752 return HRESULT(ret1) 753 } 754 755 func CoMarshalInterface(pStream *IStream, riid REFIID, pUnk *IUnknown, dwDestContext DWORD, pvDestContext uintptr, mshlFlags DWORD) HRESULT { 756 ret1 := syscall6(coMarshalInterface, 6, 757 uintptr(unsafe.Pointer(pStream)), 758 uintptr(unsafe.Pointer(riid)), 759 uintptr(unsafe.Pointer(pUnk)), 760 uintptr(dwDestContext), 761 pvDestContext, 762 uintptr(mshlFlags)) 763 return HRESULT(ret1) 764 } 765 766 func CoQueryClientBlanket(pAuthnSvc *uint32, pAuthzSvc *uint32, pServerPrincName **OLECHAR, pAuthnLevel *uint32, pImpLevel *uint32, pPrivs *RPC_AUTHZ_HANDLE, pCapabilities *uint32) HRESULT { 767 ret1 := syscall9(coQueryClientBlanket, 7, 768 uintptr(unsafe.Pointer(pAuthnSvc)), 769 uintptr(unsafe.Pointer(pAuthzSvc)), 770 uintptr(unsafe.Pointer(pServerPrincName)), 771 uintptr(unsafe.Pointer(pAuthnLevel)), 772 uintptr(unsafe.Pointer(pImpLevel)), 773 uintptr(unsafe.Pointer(pPrivs)), 774 uintptr(unsafe.Pointer(pCapabilities)), 775 0, 776 0) 777 return HRESULT(ret1) 778 } 779 780 func CoQueryProxyBlanket(pProxy *IUnknown, pAuthnSvc *uint32, pAuthzSvc *uint32, ppServerPrincName **OLECHAR, pAuthnLevel *uint32, pImpLevel *uint32, ppAuthInfo uintptr, pCapabilities *uint32) HRESULT { 781 ret1 := syscall9(coQueryProxyBlanket, 8, 782 uintptr(unsafe.Pointer(pProxy)), 783 uintptr(unsafe.Pointer(pAuthnSvc)), 784 uintptr(unsafe.Pointer(pAuthzSvc)), 785 uintptr(unsafe.Pointer(ppServerPrincName)), 786 uintptr(unsafe.Pointer(pAuthnLevel)), 787 uintptr(unsafe.Pointer(pImpLevel)), 788 ppAuthInfo, 789 uintptr(unsafe.Pointer(pCapabilities)), 790 0) 791 return HRESULT(ret1) 792 } 793 794 func CoRegisterChannelHook(guidExtension REFGUID, pChannelHook *IChannelHook) HRESULT { 795 ret1 := syscall3(coRegisterChannelHook, 2, 796 uintptr(unsafe.Pointer(guidExtension)), 797 uintptr(unsafe.Pointer(pChannelHook)), 798 0) 799 return HRESULT(ret1) 800 } 801 802 func CoRegisterClassObject(rclsid /*const*/ REFCLSID, pUnk LPUNKNOWN, dwClsContext DWORD, flags DWORD, lpdwRegister *uint32) HRESULT { 803 ret1 := syscall6(coRegisterClassObject, 5, 804 uintptr(unsafe.Pointer(rclsid)), 805 uintptr(unsafe.Pointer(pUnk)), 806 uintptr(dwClsContext), 807 uintptr(flags), 808 uintptr(unsafe.Pointer(lpdwRegister)), 809 0) 810 return HRESULT(ret1) 811 } 812 813 func CoRegisterInitializeSpy(spy *IInitializeSpy, cookie *ULARGE_INTEGER) HRESULT { 814 ret1 := syscall3(coRegisterInitializeSpy, 2, 815 uintptr(unsafe.Pointer(spy)), 816 uintptr(unsafe.Pointer(cookie)), 817 0) 818 return HRESULT(ret1) 819 } 820 821 func CoRegisterMallocSpy(pMallocSpy LPMALLOCSPY) HRESULT { 822 ret1 := syscall3(coRegisterMallocSpy, 1, 823 uintptr(unsafe.Pointer(pMallocSpy)), 824 0, 825 0) 826 return HRESULT(ret1) 827 } 828 829 func CoRegisterMessageFilter(lpMessageFilter LPMESSAGEFILTER, lplpMessageFilter *LPMESSAGEFILTER) HRESULT { 830 ret1 := syscall3(coRegisterMessageFilter, 2, 831 uintptr(unsafe.Pointer(lpMessageFilter)), 832 uintptr(unsafe.Pointer(lplpMessageFilter)), 833 0) 834 return HRESULT(ret1) 835 } 836 837 func CoRegisterPSClsid(riid REFIID, rclsid /*const*/ REFCLSID) HRESULT { 838 ret1 := syscall3(coRegisterPSClsid, 2, 839 uintptr(unsafe.Pointer(riid)), 840 uintptr(unsafe.Pointer(rclsid)), 841 0) 842 return HRESULT(ret1) 843 } 844 845 func CoReleaseMarshalData(pStream *IStream) HRESULT { 846 ret1 := syscall3(coReleaseMarshalData, 1, 847 uintptr(unsafe.Pointer(pStream)), 848 0, 849 0) 850 return HRESULT(ret1) 851 } 852 853 func CoReleaseServerProcess() ULONG { 854 ret1 := syscall3(coReleaseServerProcess, 0, 855 0, 856 0, 857 0) 858 return ULONG(ret1) 859 } 860 861 func CoResumeClassObjects() HRESULT { 862 ret1 := syscall3(coResumeClassObjects, 0, 863 0, 864 0, 865 0) 866 return HRESULT(ret1) 867 } 868 869 func CoRevertToSelf() HRESULT { 870 ret1 := syscall3(coRevertToSelf, 0, 871 0, 872 0, 873 0) 874 return HRESULT(ret1) 875 } 876 877 func CoRevokeInitializeSpy(cookie ULARGE_INTEGER) HRESULT { 878 ret1 := syscall3(coRevokeInitializeSpy, 2, 879 uintptr(*(*uint32)(unsafe.Pointer(&cookie))), 880 uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cookie)) + uintptr(4)))), 881 0) 882 return HRESULT(ret1) 883 } 884 885 func CoRevokeMallocSpy() HRESULT { 886 ret1 := syscall3(coRevokeMallocSpy, 0, 887 0, 888 0, 889 0) 890 return HRESULT(ret1) 891 } 892 893 func CoSetProxyBlanket(pProxy *IUnknown, authnSvc DWORD, authzSvc DWORD, pServerPrincName *OLECHAR, authnLevel DWORD, impLevel DWORD, pAuthInfo uintptr, capabilities DWORD) HRESULT { 894 ret1 := syscall9(coSetProxyBlanket, 8, 895 uintptr(unsafe.Pointer(pProxy)), 896 uintptr(authnSvc), 897 uintptr(authzSvc), 898 uintptr(unsafe.Pointer(pServerPrincName)), 899 uintptr(authnLevel), 900 uintptr(impLevel), 901 pAuthInfo, 902 uintptr(capabilities), 903 0) 904 return HRESULT(ret1) 905 } 906 907 func CoSetState(pv *IUnknown) HRESULT { 908 ret1 := syscall3(coSetState, 1, 909 uintptr(unsafe.Pointer(pv)), 910 0, 911 0) 912 return HRESULT(ret1) 913 } 914 915 func CoSuspendClassObjects() HRESULT { 916 ret1 := syscall3(coSuspendClassObjects, 0, 917 0, 918 0, 919 0) 920 return HRESULT(ret1) 921 } 922 923 func CoSwitchCallContext(pObject *IUnknown, ppOldObject **IUnknown) HRESULT { 924 ret1 := syscall3(coSwitchCallContext, 2, 925 uintptr(unsafe.Pointer(pObject)), 926 uintptr(unsafe.Pointer(ppOldObject)), 927 0) 928 return HRESULT(ret1) 929 } 930 931 func CoTaskMemAlloc(size SIZE_T) LPVOID { 932 ret1 := syscall3(coTaskMemAlloc, 1, 933 uintptr(size), 934 0, 935 0) 936 return (LPVOID)(unsafe.Pointer(ret1)) 937 } 938 939 func CoTaskMemFree(ptr LPVOID) { 940 syscall3(coTaskMemFree, 1, 941 uintptr(unsafe.Pointer(ptr)), 942 0, 943 0) 944 } 945 946 func CoTaskMemRealloc(pvOld LPVOID, size SIZE_T) LPVOID { 947 ret1 := syscall3(coTaskMemRealloc, 2, 948 uintptr(unsafe.Pointer(pvOld)), 949 uintptr(size), 950 0) 951 return (LPVOID)(unsafe.Pointer(ret1)) 952 } 953 954 func CoTreatAsClass(clsidOld /*const*/ REFCLSID, clsidNew /*const*/ REFCLSID) HRESULT { 955 ret1 := syscall3(coTreatAsClass, 2, 956 uintptr(unsafe.Pointer(clsidOld)), 957 uintptr(unsafe.Pointer(clsidNew)), 958 0) 959 return HRESULT(ret1) 960 } 961 962 func CoUnmarshalHresult(pStm LPSTREAM, phresult *HRESULT) HRESULT { 963 ret1 := syscall3(coUnmarshalHresult, 2, 964 uintptr(unsafe.Pointer(pStm)), 965 uintptr(unsafe.Pointer(phresult)), 966 0) 967 return HRESULT(ret1) 968 } 969 970 func CoUnmarshalInterface(pStream *IStream, riid REFIID, ppv *LPVOID) HRESULT { 971 ret1 := syscall3(coUnmarshalInterface, 3, 972 uintptr(unsafe.Pointer(pStream)), 973 uintptr(unsafe.Pointer(riid)), 974 uintptr(unsafe.Pointer(ppv))) 975 return HRESULT(ret1) 976 } 977 978 func CoWaitForMultipleHandles(dwFlags DWORD, dwTimeout DWORD, cHandles ULONG, pHandles *HANDLE, lpdwindex *uint32) HRESULT { 979 ret1 := syscall6(coWaitForMultipleHandles, 5, 980 uintptr(dwFlags), 981 uintptr(dwTimeout), 982 uintptr(cHandles), 983 uintptr(unsafe.Pointer(pHandles)), 984 uintptr(unsafe.Pointer(lpdwindex)), 985 0) 986 return HRESULT(ret1) 987 } 988 989 func CreateAntiMoniker(ppmk **IMoniker) HRESULT { 990 ret1 := syscall3(createAntiMoniker, 1, 991 uintptr(unsafe.Pointer(ppmk)), 992 0, 993 0) 994 return HRESULT(ret1) 995 } 996 997 func CreateBindCtx(reserved DWORD, ppbc *LPBC) HRESULT { 998 ret1 := syscall3(createBindCtx, 2, 999 uintptr(reserved), 1000 uintptr(unsafe.Pointer(ppbc)), 1001 0) 1002 return HRESULT(ret1) 1003 } 1004 1005 func CreateClassMoniker(rclsid /*const*/ REFCLSID, ppmk **IMoniker) HRESULT { 1006 ret1 := syscall3(createClassMoniker, 2, 1007 uintptr(unsafe.Pointer(rclsid)), 1008 uintptr(unsafe.Pointer(ppmk)), 1009 0) 1010 return HRESULT(ret1) 1011 } 1012 1013 func CreateDataAdviseHolder(ppDAHolder **IDataAdviseHolder) HRESULT { 1014 ret1 := syscall3(createDataAdviseHolder, 1, 1015 uintptr(unsafe.Pointer(ppDAHolder)), 1016 0, 1017 0) 1018 return HRESULT(ret1) 1019 } 1020 1021 func CreateDataCache(pUnkOuter LPUNKNOWN, rclsid /*const*/ REFCLSID, riid REFIID, ppvObj *LPVOID) HRESULT { 1022 ret1 := syscall6(createDataCache, 4, 1023 uintptr(unsafe.Pointer(pUnkOuter)), 1024 uintptr(unsafe.Pointer(rclsid)), 1025 uintptr(unsafe.Pointer(riid)), 1026 uintptr(unsafe.Pointer(ppvObj)), 1027 0, 1028 0) 1029 return HRESULT(ret1) 1030 } 1031 1032 func CreateFileMoniker(lpszPathName /*const*/ LPCOLESTR, ppmk **IMoniker) HRESULT { 1033 ret1 := syscall3(createFileMoniker, 2, 1034 uintptr(unsafe.Pointer(lpszPathName)), 1035 uintptr(unsafe.Pointer(ppmk)), 1036 0) 1037 return HRESULT(ret1) 1038 } 1039 1040 func CreateGenericComposite(pmkFirst *IMoniker, pmkRest *IMoniker, ppmkComposite **IMoniker) HRESULT { 1041 ret1 := syscall3(createGenericComposite, 3, 1042 uintptr(unsafe.Pointer(pmkFirst)), 1043 uintptr(unsafe.Pointer(pmkRest)), 1044 uintptr(unsafe.Pointer(ppmkComposite))) 1045 return HRESULT(ret1) 1046 } 1047 1048 func CreateILockBytesOnHGlobal(global HGLOBAL, delete_on_release bool, ret **ILockBytes) HRESULT { 1049 ret1 := syscall3(createILockBytesOnHGlobal, 3, 1050 uintptr(global), 1051 getUintptrFromBool(delete_on_release), 1052 uintptr(unsafe.Pointer(ret))) 1053 return HRESULT(ret1) 1054 } 1055 1056 func CreateItemMoniker(lpszDelim /*const*/ LPCOLESTR, lpszItem /*const*/ LPCOLESTR, ppmk **IMoniker) HRESULT { 1057 ret1 := syscall3(createItemMoniker, 3, 1058 uintptr(unsafe.Pointer(lpszDelim)), 1059 uintptr(unsafe.Pointer(lpszItem)), 1060 uintptr(unsafe.Pointer(ppmk))) 1061 return HRESULT(ret1) 1062 } 1063 1064 func CreateOleAdviseHolder(ppOAHolder **IOleAdviseHolder) HRESULT { 1065 ret1 := syscall3(createOleAdviseHolder, 1, 1066 uintptr(unsafe.Pointer(ppOAHolder)), 1067 0, 1068 0) 1069 return HRESULT(ret1) 1070 } 1071 1072 func CreatePointerMoniker(punk LPUNKNOWN, ppmk *LPMONIKER) HRESULT { 1073 ret1 := syscall3(createPointerMoniker, 2, 1074 uintptr(unsafe.Pointer(punk)), 1075 uintptr(unsafe.Pointer(ppmk)), 1076 0) 1077 return HRESULT(ret1) 1078 } 1079 1080 func CreateStreamOnHGlobal(hGlobal HGLOBAL, fDeleteOnRelease bool, ppstm *LPSTREAM) HRESULT { 1081 ret1 := syscall3(createStreamOnHGlobal, 3, 1082 uintptr(hGlobal), 1083 getUintptrFromBool(fDeleteOnRelease), 1084 uintptr(unsafe.Pointer(ppstm))) 1085 return HRESULT(ret1) 1086 } 1087 1088 func DllDebugObjectRPCHook(b bool, dummy uintptr) bool { 1089 ret1 := syscall3(dllDebugObjectRPCHook, 2, 1090 getUintptrFromBool(b), 1091 dummy, 1092 0) 1093 return ret1 != 0 1094 } 1095 1096 func DoDragDrop(pDataObject *IDataObject, pDropSource *IDropSource, dwOKEffect DWORD, pdwEffect *uint32) HRESULT { 1097 ret1 := syscall6(doDragDrop, 4, 1098 uintptr(unsafe.Pointer(pDataObject)), 1099 uintptr(unsafe.Pointer(pDropSource)), 1100 uintptr(dwOKEffect), 1101 uintptr(unsafe.Pointer(pdwEffect)), 1102 0, 1103 0) 1104 return HRESULT(ret1) 1105 } 1106 1107 func FmtIdToPropStgName(rfmtid /*const*/ *FMTID, str LPOLESTR) HRESULT { 1108 ret1 := syscall3(fmtIdToPropStgName, 2, 1109 uintptr(unsafe.Pointer(rfmtid)), 1110 uintptr(unsafe.Pointer(str)), 1111 0) 1112 return HRESULT(ret1) 1113 } 1114 1115 func FreePropVariantArray(cVariants ULONG, rgvars *PROPVARIANT) HRESULT { 1116 ret1 := syscall3(freePropVariantArray, 2, 1117 uintptr(cVariants), 1118 uintptr(unsafe.Pointer(rgvars)), 1119 0) 1120 return HRESULT(ret1) 1121 } 1122 1123 func GetClassFile(filePathName /*const*/ LPCOLESTR, pclsid *CLSID) HRESULT { 1124 ret1 := syscall3(getClassFile, 2, 1125 uintptr(unsafe.Pointer(filePathName)), 1126 uintptr(unsafe.Pointer(pclsid)), 1127 0) 1128 return HRESULT(ret1) 1129 } 1130 1131 func GetConvertStg(stg *IStorage) HRESULT { 1132 ret1 := syscall3(getConvertStg, 1, 1133 uintptr(unsafe.Pointer(stg)), 1134 0, 1135 0) 1136 return HRESULT(ret1) 1137 } 1138 1139 func GetHGlobalFromILockBytes(iface *ILockBytes, phglobal *HGLOBAL) HRESULT { 1140 ret1 := syscall3(getHGlobalFromILockBytes, 2, 1141 uintptr(unsafe.Pointer(iface)), 1142 uintptr(unsafe.Pointer(phglobal)), 1143 0) 1144 return HRESULT(ret1) 1145 } 1146 1147 func GetHGlobalFromStream(pstm *IStream, phglobal *HGLOBAL) HRESULT { 1148 ret1 := syscall3(getHGlobalFromStream, 2, 1149 uintptr(unsafe.Pointer(pstm)), 1150 uintptr(unsafe.Pointer(phglobal)), 1151 0) 1152 return HRESULT(ret1) 1153 } 1154 1155 func GetRunningObjectTable(reserved DWORD, pprot *LPRUNNINGOBJECTTABLE) HRESULT { 1156 ret1 := syscall3(getRunningObjectTable, 2, 1157 uintptr(reserved), 1158 uintptr(unsafe.Pointer(pprot)), 1159 0) 1160 return HRESULT(ret1) 1161 } 1162 1163 func IIDFromString(s /*const*/ LPCOLESTR, iid *IID) HRESULT { 1164 ret1 := syscall3(iIDFromString, 2, 1165 uintptr(unsafe.Pointer(s)), 1166 uintptr(unsafe.Pointer(iid)), 1167 0) 1168 return HRESULT(ret1) 1169 } 1170 1171 func IsAccelerator(hAccel HACCEL, cAccelEntries int32, lpMsg *MSG, lpwCmd *WORD) bool { 1172 ret1 := syscall6(isAccelerator, 4, 1173 uintptr(hAccel), 1174 uintptr(cAccelEntries), 1175 uintptr(unsafe.Pointer(lpMsg)), 1176 uintptr(unsafe.Pointer(lpwCmd)), 1177 0, 1178 0) 1179 return ret1 != 0 1180 } 1181 1182 func IsEqualGUID(rguid1 REFGUID, rguid2 REFGUID) bool { 1183 ret1 := syscall3(isEqualGUID, 2, 1184 uintptr(unsafe.Pointer(rguid1)), 1185 uintptr(unsafe.Pointer(rguid2)), 1186 0) 1187 return ret1 != 0 1188 } 1189 1190 func IsValidInterface(punk LPUNKNOWN) bool { 1191 ret1 := syscall3(isValidInterface, 1, 1192 uintptr(unsafe.Pointer(punk)), 1193 0, 1194 0) 1195 return ret1 != 0 1196 } 1197 1198 func MkParseDisplayName(pbc LPBC, szDisplayName /*const*/ LPCOLESTR, pchEaten *uint32, ppmk *LPMONIKER) HRESULT { 1199 ret1 := syscall6(mkParseDisplayName, 4, 1200 uintptr(unsafe.Pointer(pbc)), 1201 uintptr(unsafe.Pointer(szDisplayName)), 1202 uintptr(unsafe.Pointer(pchEaten)), 1203 uintptr(unsafe.Pointer(ppmk)), 1204 0, 1205 0) 1206 return HRESULT(ret1) 1207 } 1208 1209 func MonikerCommonPrefixWith(pmkThis *IMoniker, pmkOther *IMoniker, ppmkCommon **IMoniker) HRESULT { 1210 ret1 := syscall3(monikerCommonPrefixWith, 3, 1211 uintptr(unsafe.Pointer(pmkThis)), 1212 uintptr(unsafe.Pointer(pmkOther)), 1213 uintptr(unsafe.Pointer(ppmkCommon))) 1214 return HRESULT(ret1) 1215 } 1216 1217 func OleBuildVersion() DWORD { 1218 ret1 := syscall3(oleBuildVersion, 0, 1219 0, 1220 0, 1221 0) 1222 return DWORD(ret1) 1223 } 1224 1225 func OleConvertIStorageToOLESTREAM(pstg LPSTORAGE, pOleStream LPOLESTREAM) HRESULT { 1226 ret1 := syscall3(oleConvertIStorageToOLESTREAM, 2, 1227 uintptr(unsafe.Pointer(pstg)), 1228 uintptr(unsafe.Pointer(pOleStream)), 1229 0) 1230 return HRESULT(ret1) 1231 } 1232 1233 func OleConvertOLESTREAMToIStorage(pOleStream LPOLESTREAM, pstg LPSTORAGE, ptd /*const*/ *DVTARGETDEVICE) HRESULT { 1234 ret1 := syscall3(oleConvertOLESTREAMToIStorage, 3, 1235 uintptr(unsafe.Pointer(pOleStream)), 1236 uintptr(unsafe.Pointer(pstg)), 1237 uintptr(unsafe.Pointer(ptd))) 1238 return HRESULT(ret1) 1239 } 1240 1241 func OleCreate(rclsid /*const*/ REFCLSID, riid REFIID, renderopt DWORD, pFormatEtc *FORMATETC, pClientSite LPOLECLIENTSITE, pStg LPSTORAGE, ppvObj *LPVOID) HRESULT { 1242 ret1 := syscall9(oleCreate, 7, 1243 uintptr(unsafe.Pointer(rclsid)), 1244 uintptr(unsafe.Pointer(riid)), 1245 uintptr(renderopt), 1246 uintptr(unsafe.Pointer(pFormatEtc)), 1247 uintptr(unsafe.Pointer(pClientSite)), 1248 uintptr(unsafe.Pointer(pStg)), 1249 uintptr(unsafe.Pointer(ppvObj)), 1250 0, 1251 0) 1252 return HRESULT(ret1) 1253 } 1254 1255 func OleCreateDefaultHandler(clsid /*const*/ REFCLSID, pUnkOuter LPUNKNOWN, riid REFIID, ppvObj *LPVOID) HRESULT { 1256 ret1 := syscall6(oleCreateDefaultHandler, 4, 1257 uintptr(unsafe.Pointer(clsid)), 1258 uintptr(unsafe.Pointer(pUnkOuter)), 1259 uintptr(unsafe.Pointer(riid)), 1260 uintptr(unsafe.Pointer(ppvObj)), 1261 0, 1262 0) 1263 return HRESULT(ret1) 1264 } 1265 1266 func OleCreateEmbeddingHelper(clsid /*const*/ REFCLSID, pUnkOuter LPUNKNOWN, flags DWORD, pCF *IClassFactory, riid REFIID, ppvObj *LPVOID) HRESULT { 1267 ret1 := syscall6(oleCreateEmbeddingHelper, 6, 1268 uintptr(unsafe.Pointer(clsid)), 1269 uintptr(unsafe.Pointer(pUnkOuter)), 1270 uintptr(flags), 1271 uintptr(unsafe.Pointer(pCF)), 1272 uintptr(unsafe.Pointer(riid)), 1273 uintptr(unsafe.Pointer(ppvObj))) 1274 return HRESULT(ret1) 1275 } 1276 1277 func OleCreateFromData(data LPDATAOBJECT, iid REFIID, renderopt DWORD, fmt *FORMATETC, client_site LPOLECLIENTSITE, stg LPSTORAGE, obj *LPVOID) HRESULT { 1278 ret1 := syscall9(oleCreateFromData, 7, 1279 uintptr(unsafe.Pointer(data)), 1280 uintptr(unsafe.Pointer(iid)), 1281 uintptr(renderopt), 1282 uintptr(unsafe.Pointer(fmt)), 1283 uintptr(unsafe.Pointer(client_site)), 1284 uintptr(unsafe.Pointer(stg)), 1285 uintptr(unsafe.Pointer(obj)), 1286 0, 1287 0) 1288 return HRESULT(ret1) 1289 } 1290 1291 func OleCreateFromDataEx(data *IDataObject, iid REFIID, flags DWORD, renderopt DWORD, num_cache_fmts ULONG, adv_flags *uint32, cache_fmts *FORMATETC, sink *IAdviseSink, conns *uint32, client_site *IOleClientSite, stg *IStorage, obj uintptr) HRESULT { 1292 ret1 := syscall12(oleCreateFromDataEx, 12, 1293 uintptr(unsafe.Pointer(data)), 1294 uintptr(unsafe.Pointer(iid)), 1295 uintptr(flags), 1296 uintptr(renderopt), 1297 uintptr(num_cache_fmts), 1298 uintptr(unsafe.Pointer(adv_flags)), 1299 uintptr(unsafe.Pointer(cache_fmts)), 1300 uintptr(unsafe.Pointer(sink)), 1301 uintptr(unsafe.Pointer(conns)), 1302 uintptr(unsafe.Pointer(client_site)), 1303 uintptr(unsafe.Pointer(stg)), 1304 obj) 1305 return HRESULT(ret1) 1306 } 1307 1308 func OleCreateFromFile(clsid /*const*/ REFCLSID, filename /*const*/ *OLECHAR, iid REFIID, renderopt DWORD, fmt *FORMATETC, client_site *IOleClientSite, storage *IStorage, obj uintptr) HRESULT { 1309 ret1 := syscall9(oleCreateFromFile, 8, 1310 uintptr(unsafe.Pointer(clsid)), 1311 uintptr(unsafe.Pointer(filename)), 1312 uintptr(unsafe.Pointer(iid)), 1313 uintptr(renderopt), 1314 uintptr(unsafe.Pointer(fmt)), 1315 uintptr(unsafe.Pointer(client_site)), 1316 uintptr(unsafe.Pointer(storage)), 1317 obj, 1318 0) 1319 return HRESULT(ret1) 1320 } 1321 1322 func OleCreateFromFileEx(clsid /*const*/ REFCLSID, filename /*const*/ *OLECHAR, iid REFIID, flags DWORD, renderopt DWORD, num_fmts ULONG, adv_flags *uint32, fmts *FORMATETC, sink *IAdviseSink, conns *uint32, client_site *IOleClientSite, stg *IStorage, obj uintptr) HRESULT { 1323 ret1 := syscall15(oleCreateFromFileEx, 13, 1324 uintptr(unsafe.Pointer(clsid)), 1325 uintptr(unsafe.Pointer(filename)), 1326 uintptr(unsafe.Pointer(iid)), 1327 uintptr(flags), 1328 uintptr(renderopt), 1329 uintptr(num_fmts), 1330 uintptr(unsafe.Pointer(adv_flags)), 1331 uintptr(unsafe.Pointer(fmts)), 1332 uintptr(unsafe.Pointer(sink)), 1333 uintptr(unsafe.Pointer(conns)), 1334 uintptr(unsafe.Pointer(client_site)), 1335 uintptr(unsafe.Pointer(stg)), 1336 obj, 1337 0, 1338 0) 1339 return HRESULT(ret1) 1340 } 1341 1342 func OleCreateLink(pmkLinkSrc LPMONIKER, riid REFIID, renderopt DWORD, lpFormatEtc *FORMATETC, pClientSite LPOLECLIENTSITE, pStg LPSTORAGE, ppvObj *LPVOID) HRESULT { 1343 ret1 := syscall9(oleCreateLink, 7, 1344 uintptr(unsafe.Pointer(pmkLinkSrc)), 1345 uintptr(unsafe.Pointer(riid)), 1346 uintptr(renderopt), 1347 uintptr(unsafe.Pointer(lpFormatEtc)), 1348 uintptr(unsafe.Pointer(pClientSite)), 1349 uintptr(unsafe.Pointer(pStg)), 1350 uintptr(unsafe.Pointer(ppvObj)), 1351 0, 1352 0) 1353 return HRESULT(ret1) 1354 } 1355 1356 func OleCreateLinkFromData(data *IDataObject, iid REFIID, renderopt DWORD, fmt *FORMATETC, client_site *IOleClientSite, stg *IStorage, obj uintptr) HRESULT { 1357 ret1 := syscall9(oleCreateLinkFromData, 7, 1358 uintptr(unsafe.Pointer(data)), 1359 uintptr(unsafe.Pointer(iid)), 1360 uintptr(renderopt), 1361 uintptr(unsafe.Pointer(fmt)), 1362 uintptr(unsafe.Pointer(client_site)), 1363 uintptr(unsafe.Pointer(stg)), 1364 obj, 1365 0, 1366 0) 1367 return HRESULT(ret1) 1368 } 1369 1370 func OleCreateLinkToFile(lpszFileName /*const*/ LPCOLESTR, riid REFIID, renderopt DWORD, lpFormatEtc *FORMATETC, pClientSite LPOLECLIENTSITE, pStg LPSTORAGE, ppvObj *LPVOID) HRESULT { 1371 ret1 := syscall9(oleCreateLinkToFile, 7, 1372 uintptr(unsafe.Pointer(lpszFileName)), 1373 uintptr(unsafe.Pointer(riid)), 1374 uintptr(renderopt), 1375 uintptr(unsafe.Pointer(lpFormatEtc)), 1376 uintptr(unsafe.Pointer(pClientSite)), 1377 uintptr(unsafe.Pointer(pStg)), 1378 uintptr(unsafe.Pointer(ppvObj)), 1379 0, 1380 0) 1381 return HRESULT(ret1) 1382 } 1383 1384 func OleCreateMenuDescriptor(hmenuCombined HMENU, lpMenuWidths LPOLEMENUGROUPWIDTHS) HOLEMENU { 1385 ret1 := syscall3(oleCreateMenuDescriptor, 2, 1386 uintptr(hmenuCombined), 1387 uintptr(unsafe.Pointer(lpMenuWidths)), 1388 0) 1389 return HOLEMENU(ret1) 1390 } 1391 1392 func OleCreateStaticFromData(data *IDataObject, iid REFIID, renderopt DWORD, fmt *FORMATETC, client_site *IOleClientSite, stg *IStorage, obj uintptr) HRESULT { 1393 ret1 := syscall9(oleCreateStaticFromData, 7, 1394 uintptr(unsafe.Pointer(data)), 1395 uintptr(unsafe.Pointer(iid)), 1396 uintptr(renderopt), 1397 uintptr(unsafe.Pointer(fmt)), 1398 uintptr(unsafe.Pointer(client_site)), 1399 uintptr(unsafe.Pointer(stg)), 1400 obj, 1401 0, 1402 0) 1403 return HRESULT(ret1) 1404 } 1405 1406 func OleDestroyMenuDescriptor(hmenuDescriptor HOLEMENU) HRESULT { 1407 ret1 := syscall3(oleDestroyMenuDescriptor, 1, 1408 uintptr(hmenuDescriptor), 1409 0, 1410 0) 1411 return HRESULT(ret1) 1412 } 1413 1414 func OleDoAutoConvert(pStg LPSTORAGE, pClsidNew *CLSID) HRESULT { 1415 ret1 := syscall3(oleDoAutoConvert, 2, 1416 uintptr(unsafe.Pointer(pStg)), 1417 uintptr(unsafe.Pointer(pClsidNew)), 1418 0) 1419 return HRESULT(ret1) 1420 } 1421 1422 func OleDraw(pUnk *IUnknown, dwAspect DWORD, hdcDraw HDC, rect /*const*/ *RECT) HRESULT { 1423 ret1 := syscall6(oleDraw, 4, 1424 uintptr(unsafe.Pointer(pUnk)), 1425 uintptr(dwAspect), 1426 uintptr(hdcDraw), 1427 uintptr(unsafe.Pointer(rect)), 1428 0, 1429 0) 1430 return HRESULT(ret1) 1431 } 1432 1433 func OleDuplicateData(hSrc HANDLE, cfFormat CLIPFORMAT, uiFlags UINT) HANDLE { 1434 ret1 := syscall3(oleDuplicateData, 3, 1435 uintptr(hSrc), 1436 uintptr(cfFormat), 1437 uintptr(uiFlags)) 1438 return HANDLE(ret1) 1439 } 1440 1441 func OleFlushClipboard() HRESULT { 1442 ret1 := syscall3(oleFlushClipboard, 0, 1443 0, 1444 0, 1445 0) 1446 return HRESULT(ret1) 1447 } 1448 1449 func OleGetAutoConvert(clsidOld /*const*/ REFCLSID, pClsidNew *CLSID) HRESULT { 1450 ret1 := syscall3(oleGetAutoConvert, 2, 1451 uintptr(unsafe.Pointer(clsidOld)), 1452 uintptr(unsafe.Pointer(pClsidNew)), 1453 0) 1454 return HRESULT(ret1) 1455 } 1456 1457 func OleGetClipboard(obj **IDataObject) HRESULT { 1458 ret1 := syscall3(oleGetClipboard, 1, 1459 uintptr(unsafe.Pointer(obj)), 1460 0, 1461 0) 1462 return HRESULT(ret1) 1463 } 1464 1465 func OleGetIconOfClass(rclsid /*const*/ REFCLSID, lpszLabel LPOLESTR, fUseTypeAsLabel bool) HGLOBAL { 1466 ret1 := syscall3(oleGetIconOfClass, 3, 1467 uintptr(unsafe.Pointer(rclsid)), 1468 uintptr(unsafe.Pointer(lpszLabel)), 1469 getUintptrFromBool(fUseTypeAsLabel)) 1470 return HGLOBAL(ret1) 1471 } 1472 1473 func OleInitializeWOW(x DWORD, y DWORD) HRESULT { 1474 ret1 := syscall3(oleInitializeWOW, 2, 1475 uintptr(x), 1476 uintptr(y), 1477 0) 1478 return HRESULT(ret1) 1479 } 1480 1481 func OleIsCurrentClipboard(data *IDataObject) HRESULT { 1482 ret1 := syscall3(oleIsCurrentClipboard, 1, 1483 uintptr(unsafe.Pointer(data)), 1484 0, 1485 0) 1486 return HRESULT(ret1) 1487 } 1488 1489 func OleIsRunning(object LPOLEOBJECT) bool { 1490 ret1 := syscall3(oleIsRunning, 1, 1491 uintptr(unsafe.Pointer(object)), 1492 0, 1493 0) 1494 return ret1 != 0 1495 } 1496 1497 func OleLoad(pStg LPSTORAGE, riid REFIID, pClientSite LPOLECLIENTSITE, ppvObj *LPVOID) HRESULT { 1498 ret1 := syscall6(oleLoad, 4, 1499 uintptr(unsafe.Pointer(pStg)), 1500 uintptr(unsafe.Pointer(riid)), 1501 uintptr(unsafe.Pointer(pClientSite)), 1502 uintptr(unsafe.Pointer(ppvObj)), 1503 0, 1504 0) 1505 return HRESULT(ret1) 1506 } 1507 1508 func OleLoadFromStream(pStm *IStream, iidInterface REFIID, ppvObj uintptr) HRESULT { 1509 ret1 := syscall3(oleLoadFromStream, 3, 1510 uintptr(unsafe.Pointer(pStm)), 1511 uintptr(unsafe.Pointer(iidInterface)), 1512 ppvObj) 1513 return HRESULT(ret1) 1514 } 1515 1516 func OleLockRunning(pUnknown LPUNKNOWN, fLock bool, fLastUnlockCloses bool) HRESULT { 1517 ret1 := syscall3(oleLockRunning, 3, 1518 uintptr(unsafe.Pointer(pUnknown)), 1519 getUintptrFromBool(fLock), 1520 getUintptrFromBool(fLastUnlockCloses)) 1521 return HRESULT(ret1) 1522 } 1523 1524 func OleMetafilePictFromIconAndLabel(hIcon HICON, lpszLabel LPOLESTR, lpszSourceFile LPOLESTR, iIconIndex UINT) HGLOBAL { 1525 ret1 := syscall6(oleMetafilePictFromIconAndLabel, 4, 1526 uintptr(hIcon), 1527 uintptr(unsafe.Pointer(lpszLabel)), 1528 uintptr(unsafe.Pointer(lpszSourceFile)), 1529 uintptr(iIconIndex), 1530 0, 1531 0) 1532 return HGLOBAL(ret1) 1533 } 1534 1535 func OleNoteObjectVisible(pUnknown LPUNKNOWN, bVisible bool) HRESULT { 1536 ret1 := syscall3(oleNoteObjectVisible, 2, 1537 uintptr(unsafe.Pointer(pUnknown)), 1538 getUintptrFromBool(bVisible), 1539 0) 1540 return HRESULT(ret1) 1541 } 1542 1543 func OleQueryCreateFromData(data *IDataObject) HRESULT { 1544 ret1 := syscall3(oleQueryCreateFromData, 1, 1545 uintptr(unsafe.Pointer(data)), 1546 0, 1547 0) 1548 return HRESULT(ret1) 1549 } 1550 1551 func OleQueryLinkFromData(pSrcDataObject *IDataObject) HRESULT { 1552 ret1 := syscall3(oleQueryLinkFromData, 1, 1553 uintptr(unsafe.Pointer(pSrcDataObject)), 1554 0, 1555 0) 1556 return HRESULT(ret1) 1557 } 1558 1559 func OleRegEnumVerbs(clsid /*const*/ REFCLSID, ppenum *LPENUMOLEVERB) HRESULT { 1560 ret1 := syscall3(oleRegEnumVerbs, 2, 1561 uintptr(unsafe.Pointer(clsid)), 1562 uintptr(unsafe.Pointer(ppenum)), 1563 0) 1564 return HRESULT(ret1) 1565 } 1566 1567 func OleRegGetMiscStatus(clsid /*const*/ REFCLSID, dwAspect DWORD, pdwStatus *uint32) HRESULT { 1568 ret1 := syscall3(oleRegGetMiscStatus, 3, 1569 uintptr(unsafe.Pointer(clsid)), 1570 uintptr(dwAspect), 1571 uintptr(unsafe.Pointer(pdwStatus))) 1572 return HRESULT(ret1) 1573 } 1574 1575 func OleRegGetUserType(clsid /*const*/ REFCLSID, form DWORD, usertype *LPOLESTR) HRESULT { 1576 ret1 := syscall3(oleRegGetUserType, 3, 1577 uintptr(unsafe.Pointer(clsid)), 1578 uintptr(form), 1579 uintptr(unsafe.Pointer(usertype))) 1580 return HRESULT(ret1) 1581 } 1582 1583 func OleSave(pPS LPPERSISTSTORAGE, pStg LPSTORAGE, fSameAsLoad bool) HRESULT { 1584 ret1 := syscall3(oleSave, 3, 1585 uintptr(unsafe.Pointer(pPS)), 1586 uintptr(unsafe.Pointer(pStg)), 1587 getUintptrFromBool(fSameAsLoad)) 1588 return HRESULT(ret1) 1589 } 1590 1591 func OleSaveToStream(pPStm *IPersistStream, pStm *IStream) HRESULT { 1592 ret1 := syscall3(oleSaveToStream, 2, 1593 uintptr(unsafe.Pointer(pPStm)), 1594 uintptr(unsafe.Pointer(pStm)), 1595 0) 1596 return HRESULT(ret1) 1597 } 1598 1599 func OleSetAutoConvert(clsidOld /*const*/ REFCLSID, clsidNew /*const*/ REFCLSID) HRESULT { 1600 ret1 := syscall3(oleSetAutoConvert, 2, 1601 uintptr(unsafe.Pointer(clsidOld)), 1602 uintptr(unsafe.Pointer(clsidNew)), 1603 0) 1604 return HRESULT(ret1) 1605 } 1606 1607 func OleSetClipboard(data *IDataObject) HRESULT { 1608 ret1 := syscall3(oleSetClipboard, 1, 1609 uintptr(unsafe.Pointer(data)), 1610 0, 1611 0) 1612 return HRESULT(ret1) 1613 } 1614 1615 func OleSetContainedObject(pUnknown LPUNKNOWN, fContained bool) HRESULT { 1616 ret1 := syscall3(oleSetContainedObject, 2, 1617 uintptr(unsafe.Pointer(pUnknown)), 1618 getUintptrFromBool(fContained), 1619 0) 1620 return HRESULT(ret1) 1621 } 1622 1623 func OleSetMenuDescriptor(hOleMenu HOLEMENU, hwndFrame HWND, hwndActiveObject HWND, lpFrame LPOLEINPLACEFRAME, lpActiveObject LPOLEINPLACEACTIVEOBJECT) HRESULT { 1624 ret1 := syscall6(oleSetMenuDescriptor, 5, 1625 uintptr(hOleMenu), 1626 uintptr(hwndFrame), 1627 uintptr(hwndActiveObject), 1628 uintptr(unsafe.Pointer(lpFrame)), 1629 uintptr(unsafe.Pointer(lpActiveObject)), 1630 0) 1631 return HRESULT(ret1) 1632 } 1633 1634 func OleTranslateAccelerator(lpFrame LPOLEINPLACEFRAME, lpFrameInfo LPOLEINPLACEFRAMEINFO, lpmsg *MSG) HRESULT { 1635 ret1 := syscall3(oleTranslateAccelerator, 3, 1636 uintptr(unsafe.Pointer(lpFrame)), 1637 uintptr(unsafe.Pointer(lpFrameInfo)), 1638 uintptr(unsafe.Pointer(lpmsg))) 1639 return HRESULT(ret1) 1640 } 1641 1642 func PropStgNameToFmtId(str /*const*/ LPOLESTR, rfmtid *FMTID) HRESULT { 1643 ret1 := syscall3(propStgNameToFmtId, 2, 1644 uintptr(unsafe.Pointer(str)), 1645 uintptr(unsafe.Pointer(rfmtid)), 1646 0) 1647 return HRESULT(ret1) 1648 } 1649 1650 func PropSysAllocString(str /*const*/ LPCOLESTR) BSTR { 1651 ret1 := syscall3(propSysAllocString, 1, 1652 uintptr(unsafe.Pointer(str)), 1653 0, 1654 0) 1655 return (BSTR)(unsafe.Pointer(ret1)) 1656 } 1657 1658 func PropSysFreeString(str LPOLESTR) { 1659 syscall3(propSysFreeString, 1, 1660 uintptr(unsafe.Pointer(str)), 1661 0, 1662 0) 1663 } 1664 1665 func PropVariantClear(pvar *PROPVARIANT) HRESULT { 1666 ret1 := syscall3(propVariantClear, 1, 1667 uintptr(unsafe.Pointer(pvar)), 1668 0, 1669 0) 1670 return HRESULT(ret1) 1671 } 1672 1673 func PropVariantCopy(pvarDest *PROPVARIANT, pvarSrc /*const*/ *PROPVARIANT) HRESULT { 1674 ret1 := syscall3(propVariantCopy, 2, 1675 uintptr(unsafe.Pointer(pvarDest)), 1676 uintptr(unsafe.Pointer(pvarSrc)), 1677 0) 1678 return HRESULT(ret1) 1679 } 1680 1681 func ReadClassStg(pstg *IStorage, pclsid *CLSID) HRESULT { 1682 ret1 := syscall3(readClassStg, 2, 1683 uintptr(unsafe.Pointer(pstg)), 1684 uintptr(unsafe.Pointer(pclsid)), 1685 0) 1686 return HRESULT(ret1) 1687 } 1688 1689 func ReadClassStm(pStm *IStream, pclsid *CLSID) HRESULT { 1690 ret1 := syscall3(readClassStm, 2, 1691 uintptr(unsafe.Pointer(pStm)), 1692 uintptr(unsafe.Pointer(pclsid)), 1693 0) 1694 return HRESULT(ret1) 1695 } 1696 1697 func ReadFmtUserTypeStg(pstg LPSTORAGE, pcf *CLIPFORMAT, lplpszUserType *LPOLESTR) HRESULT { 1698 ret1 := syscall3(readFmtUserTypeStg, 3, 1699 uintptr(unsafe.Pointer(pstg)), 1700 uintptr(unsafe.Pointer(pcf)), 1701 uintptr(unsafe.Pointer(lplpszUserType))) 1702 return HRESULT(ret1) 1703 } 1704 1705 func RegisterDragDrop(hwnd HWND, pDropTarget LPDROPTARGET) HRESULT { 1706 ret1 := syscall3(registerDragDrop, 2, 1707 uintptr(hwnd), 1708 uintptr(unsafe.Pointer(pDropTarget)), 1709 0) 1710 return HRESULT(ret1) 1711 } 1712 1713 func ReleaseStgMedium(pmedium *STGMEDIUM) { 1714 syscall3(releaseStgMedium, 1, 1715 uintptr(unsafe.Pointer(pmedium)), 1716 0, 1717 0) 1718 } 1719 1720 func RevokeDragDrop(hwnd HWND) HRESULT { 1721 ret1 := syscall3(revokeDragDrop, 1, 1722 uintptr(hwnd), 1723 0, 1724 0) 1725 return HRESULT(ret1) 1726 } 1727 1728 func SetConvertStg(storage *IStorage, convert bool) HRESULT { 1729 ret1 := syscall3(setConvertStg, 2, 1730 uintptr(unsafe.Pointer(storage)), 1731 getUintptrFromBool(convert), 1732 0) 1733 return HRESULT(ret1) 1734 } 1735 1736 // TODO: Unknown type(s): const SERIALIZEDPROPERTYVALUE * 1737 // func StgConvertPropertyToVariant(prop /*const*/ const SERIALIZEDPROPERTYVALUE *, codePage USHORT, pvar *PROPVARIANT, pma uintptr) BOOLEAN 1738 1739 func StgCreateDocfile(pwcsName /*const*/ LPCOLESTR, grfMode DWORD, reserved DWORD, ppstgOpen **IStorage) HRESULT { 1740 ret1 := syscall6(stgCreateDocfile, 4, 1741 uintptr(unsafe.Pointer(pwcsName)), 1742 uintptr(grfMode), 1743 uintptr(reserved), 1744 uintptr(unsafe.Pointer(ppstgOpen)), 1745 0, 1746 0) 1747 return HRESULT(ret1) 1748 } 1749 1750 func StgCreateDocfileOnILockBytes(plkbyt *ILockBytes, grfMode DWORD, reserved DWORD, ppstgOpen **IStorage) HRESULT { 1751 ret1 := syscall6(stgCreateDocfileOnILockBytes, 4, 1752 uintptr(unsafe.Pointer(plkbyt)), 1753 uintptr(grfMode), 1754 uintptr(reserved), 1755 uintptr(unsafe.Pointer(ppstgOpen)), 1756 0, 1757 0) 1758 return HRESULT(ret1) 1759 } 1760 1761 func StgCreatePropSetStg(pstg *IStorage, reserved DWORD, propset **IPropertySetStorage) HRESULT { 1762 ret1 := syscall3(stgCreatePropSetStg, 3, 1763 uintptr(unsafe.Pointer(pstg)), 1764 uintptr(reserved), 1765 uintptr(unsafe.Pointer(propset))) 1766 return HRESULT(ret1) 1767 } 1768 1769 func StgCreatePropStg(unk *IUnknown, fmt REFFMTID, clsid /*const*/ *CLSID, flags DWORD, reserved DWORD, prop_stg **IPropertyStorage) HRESULT { 1770 ret1 := syscall6(stgCreatePropStg, 6, 1771 uintptr(unsafe.Pointer(unk)), 1772 uintptr(unsafe.Pointer(fmt)), 1773 uintptr(unsafe.Pointer(clsid)), 1774 uintptr(flags), 1775 uintptr(reserved), 1776 uintptr(unsafe.Pointer(prop_stg))) 1777 return HRESULT(ret1) 1778 } 1779 1780 // TODO: Unknown type(s): STGOPTIONS * 1781 // func StgCreateStorageEx(pwcsName /*const*/ *WCHAR, grfMode DWORD, stgfmt DWORD, grfAttrs DWORD, pStgOptions STGOPTIONS *, reserved uintptr, riid REFIID, ppObjectOpen uintptr) HRESULT 1782 1783 func StgIsStorageFile(fn /*const*/ LPCOLESTR) HRESULT { 1784 ret1 := syscall3(stgIsStorageFile, 1, 1785 uintptr(unsafe.Pointer(fn)), 1786 0, 1787 0) 1788 return HRESULT(ret1) 1789 } 1790 1791 func StgIsStorageILockBytes(plkbyt *ILockBytes) HRESULT { 1792 ret1 := syscall3(stgIsStorageILockBytes, 1, 1793 uintptr(unsafe.Pointer(plkbyt)), 1794 0, 1795 0) 1796 return HRESULT(ret1) 1797 } 1798 1799 func StgOpenPropStg(unk *IUnknown, fmt REFFMTID, flags DWORD, reserved DWORD, prop_stg **IPropertyStorage) HRESULT { 1800 ret1 := syscall6(stgOpenPropStg, 5, 1801 uintptr(unsafe.Pointer(unk)), 1802 uintptr(unsafe.Pointer(fmt)), 1803 uintptr(flags), 1804 uintptr(reserved), 1805 uintptr(unsafe.Pointer(prop_stg)), 1806 0) 1807 return HRESULT(ret1) 1808 } 1809 1810 // TODO: Unknown type(s): SNB 1811 // func StgOpenStorage(pwcsName /*const*/ *OLECHAR, pstgPriority *IStorage, grfMode DWORD, snbExclude SNB, reserved DWORD, ppstgOpen **IStorage) HRESULT 1812 1813 // TODO: Unknown type(s): STGOPTIONS * 1814 // func StgOpenStorageEx(pwcsName /*const*/ *WCHAR, grfMode DWORD, stgfmt DWORD, grfAttrs DWORD, pStgOptions STGOPTIONS *, reserved uintptr, riid REFIID, ppObjectOpen uintptr) HRESULT 1815 1816 // TODO: Unknown type(s): SNB 1817 // func StgOpenStorageOnILockBytes(plkbyt *ILockBytes, pstgPriority *IStorage, grfMode DWORD, snbExclude SNB, reserved DWORD, ppstgOpen **IStorage) HRESULT 1818 1819 func StgSetTimes(str /*const*/ *OLECHAR, pctime /*const*/ *FILETIME, patime /*const*/ *FILETIME, pmtime /*const*/ *FILETIME) HRESULT { 1820 ret1 := syscall6(stgSetTimes, 4, 1821 uintptr(unsafe.Pointer(str)), 1822 uintptr(unsafe.Pointer(pctime)), 1823 uintptr(unsafe.Pointer(patime)), 1824 uintptr(unsafe.Pointer(pmtime)), 1825 0, 1826 0) 1827 return HRESULT(ret1) 1828 } 1829 1830 func StringFromCLSID(id /*const*/ REFCLSID, idstr *LPOLESTR) HRESULT { 1831 ret1 := syscall3(stringFromCLSID, 2, 1832 uintptr(unsafe.Pointer(id)), 1833 uintptr(unsafe.Pointer(idstr)), 1834 0) 1835 return HRESULT(ret1) 1836 } 1837 1838 func StringFromGUID2(id REFGUID, str LPOLESTR, cmax INT) INT { 1839 ret1 := syscall3(stringFromGUID2, 3, 1840 uintptr(unsafe.Pointer(id)), 1841 uintptr(unsafe.Pointer(str)), 1842 uintptr(cmax)) 1843 return INT(ret1) 1844 } 1845 1846 func WdtpInterfacePointer_UserFree(punk *IUnknown) { 1847 syscall3(wdtpInterfacePointer_UserFree, 1, 1848 uintptr(unsafe.Pointer(punk)), 1849 0, 1850 0) 1851 } 1852 1853 func WriteClassStg(pStg *IStorage, rclsid /*const*/ REFCLSID) HRESULT { 1854 ret1 := syscall3(writeClassStg, 2, 1855 uintptr(unsafe.Pointer(pStg)), 1856 uintptr(unsafe.Pointer(rclsid)), 1857 0) 1858 return HRESULT(ret1) 1859 } 1860 1861 func WriteClassStm(pStm *IStream, rclsid /*const*/ REFCLSID) HRESULT { 1862 ret1 := syscall3(writeClassStm, 2, 1863 uintptr(unsafe.Pointer(pStm)), 1864 uintptr(unsafe.Pointer(rclsid)), 1865 0) 1866 return HRESULT(ret1) 1867 } 1868 1869 func WriteFmtUserTypeStg(pstg LPSTORAGE, cf CLIPFORMAT, lpszUserType LPOLESTR) HRESULT { 1870 ret1 := syscall3(writeFmtUserTypeStg, 3, 1871 uintptr(unsafe.Pointer(pstg)), 1872 uintptr(cf), 1873 uintptr(unsafe.Pointer(lpszUserType))) 1874 return HRESULT(ret1) 1875 }